twilio_openapi/apis/
default_api.rs

1/*
2 * Twilio - Api
3 *
4 * This is the public Twilio REST API.
5 *
6 * The version of the OpenAPI document: 1.37.3
7 * Contact: support@twilio.com
8 * Generated by: https://openapi-generator.tech
9 */
10
11
12use reqwest;
13
14use crate::apis::ResponseContent;
15use super::{Error, configuration};
16
17
18/// struct for typed errors of method [`create_account`]
19#[derive(Debug, Clone, Serialize, Deserialize)]
20#[serde(untagged)]
21pub enum CreateAccountError {
22    UnknownValue(serde_json::Value),
23}
24
25/// struct for typed errors of method [`create_address`]
26#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(untagged)]
28pub enum CreateAddressError {
29    UnknownValue(serde_json::Value),
30}
31
32/// struct for typed errors of method [`create_application`]
33#[derive(Debug, Clone, Serialize, Deserialize)]
34#[serde(untagged)]
35pub enum CreateApplicationError {
36    UnknownValue(serde_json::Value),
37}
38
39/// struct for typed errors of method [`create_call`]
40#[derive(Debug, Clone, Serialize, Deserialize)]
41#[serde(untagged)]
42pub enum CreateCallError {
43    UnknownValue(serde_json::Value),
44}
45
46/// struct for typed errors of method [`create_call_feedback_summary`]
47#[derive(Debug, Clone, Serialize, Deserialize)]
48#[serde(untagged)]
49pub enum CreateCallFeedbackSummaryError {
50    UnknownValue(serde_json::Value),
51}
52
53/// struct for typed errors of method [`create_call_recording`]
54#[derive(Debug, Clone, Serialize, Deserialize)]
55#[serde(untagged)]
56pub enum CreateCallRecordingError {
57    UnknownValue(serde_json::Value),
58}
59
60/// struct for typed errors of method [`create_incoming_phone_number`]
61#[derive(Debug, Clone, Serialize, Deserialize)]
62#[serde(untagged)]
63pub enum CreateIncomingPhoneNumberError {
64    UnknownValue(serde_json::Value),
65}
66
67/// struct for typed errors of method [`create_incoming_phone_number_assigned_add_on`]
68#[derive(Debug, Clone, Serialize, Deserialize)]
69#[serde(untagged)]
70pub enum CreateIncomingPhoneNumberAssignedAddOnError {
71    UnknownValue(serde_json::Value),
72}
73
74/// struct for typed errors of method [`create_incoming_phone_number_local`]
75#[derive(Debug, Clone, Serialize, Deserialize)]
76#[serde(untagged)]
77pub enum CreateIncomingPhoneNumberLocalError {
78    UnknownValue(serde_json::Value),
79}
80
81/// struct for typed errors of method [`create_incoming_phone_number_mobile`]
82#[derive(Debug, Clone, Serialize, Deserialize)]
83#[serde(untagged)]
84pub enum CreateIncomingPhoneNumberMobileError {
85    UnknownValue(serde_json::Value),
86}
87
88/// struct for typed errors of method [`create_incoming_phone_number_toll_free`]
89#[derive(Debug, Clone, Serialize, Deserialize)]
90#[serde(untagged)]
91pub enum CreateIncomingPhoneNumberTollFreeError {
92    UnknownValue(serde_json::Value),
93}
94
95/// struct for typed errors of method [`create_message`]
96#[derive(Debug, Clone, Serialize, Deserialize)]
97#[serde(untagged)]
98pub enum CreateMessageError {
99    UnknownValue(serde_json::Value),
100}
101
102/// struct for typed errors of method [`create_message_feedback`]
103#[derive(Debug, Clone, Serialize, Deserialize)]
104#[serde(untagged)]
105pub enum CreateMessageFeedbackError {
106    UnknownValue(serde_json::Value),
107}
108
109/// struct for typed errors of method [`create_new_key`]
110#[derive(Debug, Clone, Serialize, Deserialize)]
111#[serde(untagged)]
112pub enum CreateNewKeyError {
113    UnknownValue(serde_json::Value),
114}
115
116/// struct for typed errors of method [`create_new_signing_key`]
117#[derive(Debug, Clone, Serialize, Deserialize)]
118#[serde(untagged)]
119pub enum CreateNewSigningKeyError {
120    UnknownValue(serde_json::Value),
121}
122
123/// struct for typed errors of method [`create_participant`]
124#[derive(Debug, Clone, Serialize, Deserialize)]
125#[serde(untagged)]
126pub enum CreateParticipantError {
127    UnknownValue(serde_json::Value),
128}
129
130/// struct for typed errors of method [`create_payments`]
131#[derive(Debug, Clone, Serialize, Deserialize)]
132#[serde(untagged)]
133pub enum CreatePaymentsError {
134    UnknownValue(serde_json::Value),
135}
136
137/// struct for typed errors of method [`create_queue`]
138#[derive(Debug, Clone, Serialize, Deserialize)]
139#[serde(untagged)]
140pub enum CreateQueueError {
141    UnknownValue(serde_json::Value),
142}
143
144/// struct for typed errors of method [`create_sip_auth_calls_credential_list_mapping`]
145#[derive(Debug, Clone, Serialize, Deserialize)]
146#[serde(untagged)]
147pub enum CreateSipAuthCallsCredentialListMappingError {
148    UnknownValue(serde_json::Value),
149}
150
151/// struct for typed errors of method [`create_sip_auth_calls_ip_access_control_list_mapping`]
152#[derive(Debug, Clone, Serialize, Deserialize)]
153#[serde(untagged)]
154pub enum CreateSipAuthCallsIpAccessControlListMappingError {
155    UnknownValue(serde_json::Value),
156}
157
158/// struct for typed errors of method [`create_sip_auth_registrations_credential_list_mapping`]
159#[derive(Debug, Clone, Serialize, Deserialize)]
160#[serde(untagged)]
161pub enum CreateSipAuthRegistrationsCredentialListMappingError {
162    UnknownValue(serde_json::Value),
163}
164
165/// struct for typed errors of method [`create_sip_credential`]
166#[derive(Debug, Clone, Serialize, Deserialize)]
167#[serde(untagged)]
168pub enum CreateSipCredentialError {
169    UnknownValue(serde_json::Value),
170}
171
172/// struct for typed errors of method [`create_sip_credential_list`]
173#[derive(Debug, Clone, Serialize, Deserialize)]
174#[serde(untagged)]
175pub enum CreateSipCredentialListError {
176    UnknownValue(serde_json::Value),
177}
178
179/// struct for typed errors of method [`create_sip_credential_list_mapping`]
180#[derive(Debug, Clone, Serialize, Deserialize)]
181#[serde(untagged)]
182pub enum CreateSipCredentialListMappingError {
183    UnknownValue(serde_json::Value),
184}
185
186/// struct for typed errors of method [`create_sip_domain`]
187#[derive(Debug, Clone, Serialize, Deserialize)]
188#[serde(untagged)]
189pub enum CreateSipDomainError {
190    UnknownValue(serde_json::Value),
191}
192
193/// struct for typed errors of method [`create_sip_ip_access_control_list`]
194#[derive(Debug, Clone, Serialize, Deserialize)]
195#[serde(untagged)]
196pub enum CreateSipIpAccessControlListError {
197    UnknownValue(serde_json::Value),
198}
199
200/// struct for typed errors of method [`create_sip_ip_access_control_list_mapping`]
201#[derive(Debug, Clone, Serialize, Deserialize)]
202#[serde(untagged)]
203pub enum CreateSipIpAccessControlListMappingError {
204    UnknownValue(serde_json::Value),
205}
206
207/// struct for typed errors of method [`create_sip_ip_address`]
208#[derive(Debug, Clone, Serialize, Deserialize)]
209#[serde(untagged)]
210pub enum CreateSipIpAddressError {
211    UnknownValue(serde_json::Value),
212}
213
214/// struct for typed errors of method [`create_siprec`]
215#[derive(Debug, Clone, Serialize, Deserialize)]
216#[serde(untagged)]
217pub enum CreateSiprecError {
218    UnknownValue(serde_json::Value),
219}
220
221/// struct for typed errors of method [`create_stream`]
222#[derive(Debug, Clone, Serialize, Deserialize)]
223#[serde(untagged)]
224pub enum CreateStreamError {
225    UnknownValue(serde_json::Value),
226}
227
228/// struct for typed errors of method [`create_token`]
229#[derive(Debug, Clone, Serialize, Deserialize)]
230#[serde(untagged)]
231pub enum CreateTokenError {
232    UnknownValue(serde_json::Value),
233}
234
235/// struct for typed errors of method [`create_usage_trigger`]
236#[derive(Debug, Clone, Serialize, Deserialize)]
237#[serde(untagged)]
238pub enum CreateUsageTriggerError {
239    UnknownValue(serde_json::Value),
240}
241
242/// struct for typed errors of method [`create_user_defined_message`]
243#[derive(Debug, Clone, Serialize, Deserialize)]
244#[serde(untagged)]
245pub enum CreateUserDefinedMessageError {
246    UnknownValue(serde_json::Value),
247}
248
249/// struct for typed errors of method [`create_user_defined_message_subscription`]
250#[derive(Debug, Clone, Serialize, Deserialize)]
251#[serde(untagged)]
252pub enum CreateUserDefinedMessageSubscriptionError {
253    UnknownValue(serde_json::Value),
254}
255
256/// struct for typed errors of method [`create_validation_request`]
257#[derive(Debug, Clone, Serialize, Deserialize)]
258#[serde(untagged)]
259pub enum CreateValidationRequestError {
260    UnknownValue(serde_json::Value),
261}
262
263/// struct for typed errors of method [`delete_address`]
264#[derive(Debug, Clone, Serialize, Deserialize)]
265#[serde(untagged)]
266pub enum DeleteAddressError {
267    UnknownValue(serde_json::Value),
268}
269
270/// struct for typed errors of method [`delete_application`]
271#[derive(Debug, Clone, Serialize, Deserialize)]
272#[serde(untagged)]
273pub enum DeleteApplicationError {
274    UnknownValue(serde_json::Value),
275}
276
277/// struct for typed errors of method [`delete_call`]
278#[derive(Debug, Clone, Serialize, Deserialize)]
279#[serde(untagged)]
280pub enum DeleteCallError {
281    UnknownValue(serde_json::Value),
282}
283
284/// struct for typed errors of method [`delete_call_feedback_summary`]
285#[derive(Debug, Clone, Serialize, Deserialize)]
286#[serde(untagged)]
287pub enum DeleteCallFeedbackSummaryError {
288    UnknownValue(serde_json::Value),
289}
290
291/// struct for typed errors of method [`delete_call_recording`]
292#[derive(Debug, Clone, Serialize, Deserialize)]
293#[serde(untagged)]
294pub enum DeleteCallRecordingError {
295    UnknownValue(serde_json::Value),
296}
297
298/// struct for typed errors of method [`delete_conference_recording`]
299#[derive(Debug, Clone, Serialize, Deserialize)]
300#[serde(untagged)]
301pub enum DeleteConferenceRecordingError {
302    UnknownValue(serde_json::Value),
303}
304
305/// struct for typed errors of method [`delete_connect_app`]
306#[derive(Debug, Clone, Serialize, Deserialize)]
307#[serde(untagged)]
308pub enum DeleteConnectAppError {
309    UnknownValue(serde_json::Value),
310}
311
312/// struct for typed errors of method [`delete_incoming_phone_number`]
313#[derive(Debug, Clone, Serialize, Deserialize)]
314#[serde(untagged)]
315pub enum DeleteIncomingPhoneNumberError {
316    UnknownValue(serde_json::Value),
317}
318
319/// struct for typed errors of method [`delete_incoming_phone_number_assigned_add_on`]
320#[derive(Debug, Clone, Serialize, Deserialize)]
321#[serde(untagged)]
322pub enum DeleteIncomingPhoneNumberAssignedAddOnError {
323    UnknownValue(serde_json::Value),
324}
325
326/// struct for typed errors of method [`delete_key`]
327#[derive(Debug, Clone, Serialize, Deserialize)]
328#[serde(untagged)]
329pub enum DeleteKeyError {
330    UnknownValue(serde_json::Value),
331}
332
333/// struct for typed errors of method [`delete_media`]
334#[derive(Debug, Clone, Serialize, Deserialize)]
335#[serde(untagged)]
336pub enum DeleteMediaError {
337    UnknownValue(serde_json::Value),
338}
339
340/// struct for typed errors of method [`delete_message`]
341#[derive(Debug, Clone, Serialize, Deserialize)]
342#[serde(untagged)]
343pub enum DeleteMessageError {
344    UnknownValue(serde_json::Value),
345}
346
347/// struct for typed errors of method [`delete_outgoing_caller_id`]
348#[derive(Debug, Clone, Serialize, Deserialize)]
349#[serde(untagged)]
350pub enum DeleteOutgoingCallerIdError {
351    UnknownValue(serde_json::Value),
352}
353
354/// struct for typed errors of method [`delete_participant`]
355#[derive(Debug, Clone, Serialize, Deserialize)]
356#[serde(untagged)]
357pub enum DeleteParticipantError {
358    UnknownValue(serde_json::Value),
359}
360
361/// struct for typed errors of method [`delete_queue`]
362#[derive(Debug, Clone, Serialize, Deserialize)]
363#[serde(untagged)]
364pub enum DeleteQueueError {
365    UnknownValue(serde_json::Value),
366}
367
368/// struct for typed errors of method [`delete_recording`]
369#[derive(Debug, Clone, Serialize, Deserialize)]
370#[serde(untagged)]
371pub enum DeleteRecordingError {
372    UnknownValue(serde_json::Value),
373}
374
375/// struct for typed errors of method [`delete_recording_add_on_result`]
376#[derive(Debug, Clone, Serialize, Deserialize)]
377#[serde(untagged)]
378pub enum DeleteRecordingAddOnResultError {
379    UnknownValue(serde_json::Value),
380}
381
382/// struct for typed errors of method [`delete_recording_add_on_result_payload`]
383#[derive(Debug, Clone, Serialize, Deserialize)]
384#[serde(untagged)]
385pub enum DeleteRecordingAddOnResultPayloadError {
386    UnknownValue(serde_json::Value),
387}
388
389/// struct for typed errors of method [`delete_recording_transcription`]
390#[derive(Debug, Clone, Serialize, Deserialize)]
391#[serde(untagged)]
392pub enum DeleteRecordingTranscriptionError {
393    UnknownValue(serde_json::Value),
394}
395
396/// struct for typed errors of method [`delete_signing_key`]
397#[derive(Debug, Clone, Serialize, Deserialize)]
398#[serde(untagged)]
399pub enum DeleteSigningKeyError {
400    UnknownValue(serde_json::Value),
401}
402
403/// struct for typed errors of method [`delete_sip_auth_calls_credential_list_mapping`]
404#[derive(Debug, Clone, Serialize, Deserialize)]
405#[serde(untagged)]
406pub enum DeleteSipAuthCallsCredentialListMappingError {
407    UnknownValue(serde_json::Value),
408}
409
410/// struct for typed errors of method [`delete_sip_auth_calls_ip_access_control_list_mapping`]
411#[derive(Debug, Clone, Serialize, Deserialize)]
412#[serde(untagged)]
413pub enum DeleteSipAuthCallsIpAccessControlListMappingError {
414    UnknownValue(serde_json::Value),
415}
416
417/// struct for typed errors of method [`delete_sip_auth_registrations_credential_list_mapping`]
418#[derive(Debug, Clone, Serialize, Deserialize)]
419#[serde(untagged)]
420pub enum DeleteSipAuthRegistrationsCredentialListMappingError {
421    UnknownValue(serde_json::Value),
422}
423
424/// struct for typed errors of method [`delete_sip_credential`]
425#[derive(Debug, Clone, Serialize, Deserialize)]
426#[serde(untagged)]
427pub enum DeleteSipCredentialError {
428    UnknownValue(serde_json::Value),
429}
430
431/// struct for typed errors of method [`delete_sip_credential_list`]
432#[derive(Debug, Clone, Serialize, Deserialize)]
433#[serde(untagged)]
434pub enum DeleteSipCredentialListError {
435    UnknownValue(serde_json::Value),
436}
437
438/// struct for typed errors of method [`delete_sip_credential_list_mapping`]
439#[derive(Debug, Clone, Serialize, Deserialize)]
440#[serde(untagged)]
441pub enum DeleteSipCredentialListMappingError {
442    UnknownValue(serde_json::Value),
443}
444
445/// struct for typed errors of method [`delete_sip_domain`]
446#[derive(Debug, Clone, Serialize, Deserialize)]
447#[serde(untagged)]
448pub enum DeleteSipDomainError {
449    UnknownValue(serde_json::Value),
450}
451
452/// struct for typed errors of method [`delete_sip_ip_access_control_list`]
453#[derive(Debug, Clone, Serialize, Deserialize)]
454#[serde(untagged)]
455pub enum DeleteSipIpAccessControlListError {
456    UnknownValue(serde_json::Value),
457}
458
459/// struct for typed errors of method [`delete_sip_ip_access_control_list_mapping`]
460#[derive(Debug, Clone, Serialize, Deserialize)]
461#[serde(untagged)]
462pub enum DeleteSipIpAccessControlListMappingError {
463    UnknownValue(serde_json::Value),
464}
465
466/// struct for typed errors of method [`delete_sip_ip_address`]
467#[derive(Debug, Clone, Serialize, Deserialize)]
468#[serde(untagged)]
469pub enum DeleteSipIpAddressError {
470    UnknownValue(serde_json::Value),
471}
472
473/// struct for typed errors of method [`delete_transcription`]
474#[derive(Debug, Clone, Serialize, Deserialize)]
475#[serde(untagged)]
476pub enum DeleteTranscriptionError {
477    UnknownValue(serde_json::Value),
478}
479
480/// struct for typed errors of method [`delete_usage_trigger`]
481#[derive(Debug, Clone, Serialize, Deserialize)]
482#[serde(untagged)]
483pub enum DeleteUsageTriggerError {
484    UnknownValue(serde_json::Value),
485}
486
487/// struct for typed errors of method [`delete_user_defined_message_subscription`]
488#[derive(Debug, Clone, Serialize, Deserialize)]
489#[serde(untagged)]
490pub enum DeleteUserDefinedMessageSubscriptionError {
491    UnknownValue(serde_json::Value),
492}
493
494/// struct for typed errors of method [`fetch_account`]
495#[derive(Debug, Clone, Serialize, Deserialize)]
496#[serde(untagged)]
497pub enum FetchAccountError {
498    UnknownValue(serde_json::Value),
499}
500
501/// struct for typed errors of method [`fetch_address`]
502#[derive(Debug, Clone, Serialize, Deserialize)]
503#[serde(untagged)]
504pub enum FetchAddressError {
505    UnknownValue(serde_json::Value),
506}
507
508/// struct for typed errors of method [`fetch_application`]
509#[derive(Debug, Clone, Serialize, Deserialize)]
510#[serde(untagged)]
511pub enum FetchApplicationError {
512    UnknownValue(serde_json::Value),
513}
514
515/// struct for typed errors of method [`fetch_authorized_connect_app`]
516#[derive(Debug, Clone, Serialize, Deserialize)]
517#[serde(untagged)]
518pub enum FetchAuthorizedConnectAppError {
519    UnknownValue(serde_json::Value),
520}
521
522/// struct for typed errors of method [`fetch_available_phone_number_country`]
523#[derive(Debug, Clone, Serialize, Deserialize)]
524#[serde(untagged)]
525pub enum FetchAvailablePhoneNumberCountryError {
526    UnknownValue(serde_json::Value),
527}
528
529/// struct for typed errors of method [`fetch_balance`]
530#[derive(Debug, Clone, Serialize, Deserialize)]
531#[serde(untagged)]
532pub enum FetchBalanceError {
533    UnknownValue(serde_json::Value),
534}
535
536/// struct for typed errors of method [`fetch_call`]
537#[derive(Debug, Clone, Serialize, Deserialize)]
538#[serde(untagged)]
539pub enum FetchCallError {
540    UnknownValue(serde_json::Value),
541}
542
543/// struct for typed errors of method [`fetch_call_feedback`]
544#[derive(Debug, Clone, Serialize, Deserialize)]
545#[serde(untagged)]
546pub enum FetchCallFeedbackError {
547    UnknownValue(serde_json::Value),
548}
549
550/// struct for typed errors of method [`fetch_call_feedback_summary`]
551#[derive(Debug, Clone, Serialize, Deserialize)]
552#[serde(untagged)]
553pub enum FetchCallFeedbackSummaryError {
554    UnknownValue(serde_json::Value),
555}
556
557/// struct for typed errors of method [`fetch_call_notification`]
558#[derive(Debug, Clone, Serialize, Deserialize)]
559#[serde(untagged)]
560pub enum FetchCallNotificationError {
561    UnknownValue(serde_json::Value),
562}
563
564/// struct for typed errors of method [`fetch_call_recording`]
565#[derive(Debug, Clone, Serialize, Deserialize)]
566#[serde(untagged)]
567pub enum FetchCallRecordingError {
568    UnknownValue(serde_json::Value),
569}
570
571/// struct for typed errors of method [`fetch_conference`]
572#[derive(Debug, Clone, Serialize, Deserialize)]
573#[serde(untagged)]
574pub enum FetchConferenceError {
575    UnknownValue(serde_json::Value),
576}
577
578/// struct for typed errors of method [`fetch_conference_recording`]
579#[derive(Debug, Clone, Serialize, Deserialize)]
580#[serde(untagged)]
581pub enum FetchConferenceRecordingError {
582    UnknownValue(serde_json::Value),
583}
584
585/// struct for typed errors of method [`fetch_connect_app`]
586#[derive(Debug, Clone, Serialize, Deserialize)]
587#[serde(untagged)]
588pub enum FetchConnectAppError {
589    UnknownValue(serde_json::Value),
590}
591
592/// struct for typed errors of method [`fetch_incoming_phone_number`]
593#[derive(Debug, Clone, Serialize, Deserialize)]
594#[serde(untagged)]
595pub enum FetchIncomingPhoneNumberError {
596    UnknownValue(serde_json::Value),
597}
598
599/// struct for typed errors of method [`fetch_incoming_phone_number_assigned_add_on`]
600#[derive(Debug, Clone, Serialize, Deserialize)]
601#[serde(untagged)]
602pub enum FetchIncomingPhoneNumberAssignedAddOnError {
603    UnknownValue(serde_json::Value),
604}
605
606/// struct for typed errors of method [`fetch_incoming_phone_number_assigned_add_on_extension`]
607#[derive(Debug, Clone, Serialize, Deserialize)]
608#[serde(untagged)]
609pub enum FetchIncomingPhoneNumberAssignedAddOnExtensionError {
610    UnknownValue(serde_json::Value),
611}
612
613/// struct for typed errors of method [`fetch_key`]
614#[derive(Debug, Clone, Serialize, Deserialize)]
615#[serde(untagged)]
616pub enum FetchKeyError {
617    UnknownValue(serde_json::Value),
618}
619
620/// struct for typed errors of method [`fetch_media`]
621#[derive(Debug, Clone, Serialize, Deserialize)]
622#[serde(untagged)]
623pub enum FetchMediaError {
624    UnknownValue(serde_json::Value),
625}
626
627/// struct for typed errors of method [`fetch_member`]
628#[derive(Debug, Clone, Serialize, Deserialize)]
629#[serde(untagged)]
630pub enum FetchMemberError {
631    UnknownValue(serde_json::Value),
632}
633
634/// struct for typed errors of method [`fetch_message`]
635#[derive(Debug, Clone, Serialize, Deserialize)]
636#[serde(untagged)]
637pub enum FetchMessageError {
638    UnknownValue(serde_json::Value),
639}
640
641/// struct for typed errors of method [`fetch_notification`]
642#[derive(Debug, Clone, Serialize, Deserialize)]
643#[serde(untagged)]
644pub enum FetchNotificationError {
645    UnknownValue(serde_json::Value),
646}
647
648/// struct for typed errors of method [`fetch_outgoing_caller_id`]
649#[derive(Debug, Clone, Serialize, Deserialize)]
650#[serde(untagged)]
651pub enum FetchOutgoingCallerIdError {
652    UnknownValue(serde_json::Value),
653}
654
655/// struct for typed errors of method [`fetch_participant`]
656#[derive(Debug, Clone, Serialize, Deserialize)]
657#[serde(untagged)]
658pub enum FetchParticipantError {
659    UnknownValue(serde_json::Value),
660}
661
662/// struct for typed errors of method [`fetch_queue`]
663#[derive(Debug, Clone, Serialize, Deserialize)]
664#[serde(untagged)]
665pub enum FetchQueueError {
666    UnknownValue(serde_json::Value),
667}
668
669/// struct for typed errors of method [`fetch_recording`]
670#[derive(Debug, Clone, Serialize, Deserialize)]
671#[serde(untagged)]
672pub enum FetchRecordingError {
673    UnknownValue(serde_json::Value),
674}
675
676/// struct for typed errors of method [`fetch_recording_add_on_result`]
677#[derive(Debug, Clone, Serialize, Deserialize)]
678#[serde(untagged)]
679pub enum FetchRecordingAddOnResultError {
680    UnknownValue(serde_json::Value),
681}
682
683/// struct for typed errors of method [`fetch_recording_add_on_result_payload`]
684#[derive(Debug, Clone, Serialize, Deserialize)]
685#[serde(untagged)]
686pub enum FetchRecordingAddOnResultPayloadError {
687    UnknownValue(serde_json::Value),
688}
689
690/// struct for typed errors of method [`fetch_recording_transcription`]
691#[derive(Debug, Clone, Serialize, Deserialize)]
692#[serde(untagged)]
693pub enum FetchRecordingTranscriptionError {
694    UnknownValue(serde_json::Value),
695}
696
697/// struct for typed errors of method [`fetch_short_code`]
698#[derive(Debug, Clone, Serialize, Deserialize)]
699#[serde(untagged)]
700pub enum FetchShortCodeError {
701    UnknownValue(serde_json::Value),
702}
703
704/// struct for typed errors of method [`fetch_signing_key`]
705#[derive(Debug, Clone, Serialize, Deserialize)]
706#[serde(untagged)]
707pub enum FetchSigningKeyError {
708    UnknownValue(serde_json::Value),
709}
710
711/// struct for typed errors of method [`fetch_sip_auth_calls_credential_list_mapping`]
712#[derive(Debug, Clone, Serialize, Deserialize)]
713#[serde(untagged)]
714pub enum FetchSipAuthCallsCredentialListMappingError {
715    UnknownValue(serde_json::Value),
716}
717
718/// struct for typed errors of method [`fetch_sip_auth_calls_ip_access_control_list_mapping`]
719#[derive(Debug, Clone, Serialize, Deserialize)]
720#[serde(untagged)]
721pub enum FetchSipAuthCallsIpAccessControlListMappingError {
722    UnknownValue(serde_json::Value),
723}
724
725/// struct for typed errors of method [`fetch_sip_auth_registrations_credential_list_mapping`]
726#[derive(Debug, Clone, Serialize, Deserialize)]
727#[serde(untagged)]
728pub enum FetchSipAuthRegistrationsCredentialListMappingError {
729    UnknownValue(serde_json::Value),
730}
731
732/// struct for typed errors of method [`fetch_sip_credential`]
733#[derive(Debug, Clone, Serialize, Deserialize)]
734#[serde(untagged)]
735pub enum FetchSipCredentialError {
736    UnknownValue(serde_json::Value),
737}
738
739/// struct for typed errors of method [`fetch_sip_credential_list`]
740#[derive(Debug, Clone, Serialize, Deserialize)]
741#[serde(untagged)]
742pub enum FetchSipCredentialListError {
743    UnknownValue(serde_json::Value),
744}
745
746/// struct for typed errors of method [`fetch_sip_credential_list_mapping`]
747#[derive(Debug, Clone, Serialize, Deserialize)]
748#[serde(untagged)]
749pub enum FetchSipCredentialListMappingError {
750    UnknownValue(serde_json::Value),
751}
752
753/// struct for typed errors of method [`fetch_sip_domain`]
754#[derive(Debug, Clone, Serialize, Deserialize)]
755#[serde(untagged)]
756pub enum FetchSipDomainError {
757    UnknownValue(serde_json::Value),
758}
759
760/// struct for typed errors of method [`fetch_sip_ip_access_control_list`]
761#[derive(Debug, Clone, Serialize, Deserialize)]
762#[serde(untagged)]
763pub enum FetchSipIpAccessControlListError {
764    UnknownValue(serde_json::Value),
765}
766
767/// struct for typed errors of method [`fetch_sip_ip_access_control_list_mapping`]
768#[derive(Debug, Clone, Serialize, Deserialize)]
769#[serde(untagged)]
770pub enum FetchSipIpAccessControlListMappingError {
771    UnknownValue(serde_json::Value),
772}
773
774/// struct for typed errors of method [`fetch_sip_ip_address`]
775#[derive(Debug, Clone, Serialize, Deserialize)]
776#[serde(untagged)]
777pub enum FetchSipIpAddressError {
778    UnknownValue(serde_json::Value),
779}
780
781/// struct for typed errors of method [`fetch_transcription`]
782#[derive(Debug, Clone, Serialize, Deserialize)]
783#[serde(untagged)]
784pub enum FetchTranscriptionError {
785    UnknownValue(serde_json::Value),
786}
787
788/// struct for typed errors of method [`fetch_usage_trigger`]
789#[derive(Debug, Clone, Serialize, Deserialize)]
790#[serde(untagged)]
791pub enum FetchUsageTriggerError {
792    UnknownValue(serde_json::Value),
793}
794
795/// struct for typed errors of method [`list_account`]
796#[derive(Debug, Clone, Serialize, Deserialize)]
797#[serde(untagged)]
798pub enum ListAccountError {
799    UnknownValue(serde_json::Value),
800}
801
802/// struct for typed errors of method [`list_address`]
803#[derive(Debug, Clone, Serialize, Deserialize)]
804#[serde(untagged)]
805pub enum ListAddressError {
806    UnknownValue(serde_json::Value),
807}
808
809/// struct for typed errors of method [`list_application`]
810#[derive(Debug, Clone, Serialize, Deserialize)]
811#[serde(untagged)]
812pub enum ListApplicationError {
813    UnknownValue(serde_json::Value),
814}
815
816/// struct for typed errors of method [`list_authorized_connect_app`]
817#[derive(Debug, Clone, Serialize, Deserialize)]
818#[serde(untagged)]
819pub enum ListAuthorizedConnectAppError {
820    UnknownValue(serde_json::Value),
821}
822
823/// struct for typed errors of method [`list_available_phone_number_country`]
824#[derive(Debug, Clone, Serialize, Deserialize)]
825#[serde(untagged)]
826pub enum ListAvailablePhoneNumberCountryError {
827    UnknownValue(serde_json::Value),
828}
829
830/// struct for typed errors of method [`list_available_phone_number_local`]
831#[derive(Debug, Clone, Serialize, Deserialize)]
832#[serde(untagged)]
833pub enum ListAvailablePhoneNumberLocalError {
834    UnknownValue(serde_json::Value),
835}
836
837/// struct for typed errors of method [`list_available_phone_number_machine_to_machine`]
838#[derive(Debug, Clone, Serialize, Deserialize)]
839#[serde(untagged)]
840pub enum ListAvailablePhoneNumberMachineToMachineError {
841    UnknownValue(serde_json::Value),
842}
843
844/// struct for typed errors of method [`list_available_phone_number_mobile`]
845#[derive(Debug, Clone, Serialize, Deserialize)]
846#[serde(untagged)]
847pub enum ListAvailablePhoneNumberMobileError {
848    UnknownValue(serde_json::Value),
849}
850
851/// struct for typed errors of method [`list_available_phone_number_national`]
852#[derive(Debug, Clone, Serialize, Deserialize)]
853#[serde(untagged)]
854pub enum ListAvailablePhoneNumberNationalError {
855    UnknownValue(serde_json::Value),
856}
857
858/// struct for typed errors of method [`list_available_phone_number_shared_cost`]
859#[derive(Debug, Clone, Serialize, Deserialize)]
860#[serde(untagged)]
861pub enum ListAvailablePhoneNumberSharedCostError {
862    UnknownValue(serde_json::Value),
863}
864
865/// struct for typed errors of method [`list_available_phone_number_toll_free`]
866#[derive(Debug, Clone, Serialize, Deserialize)]
867#[serde(untagged)]
868pub enum ListAvailablePhoneNumberTollFreeError {
869    UnknownValue(serde_json::Value),
870}
871
872/// struct for typed errors of method [`list_available_phone_number_voip`]
873#[derive(Debug, Clone, Serialize, Deserialize)]
874#[serde(untagged)]
875pub enum ListAvailablePhoneNumberVoipError {
876    UnknownValue(serde_json::Value),
877}
878
879/// struct for typed errors of method [`list_call`]
880#[derive(Debug, Clone, Serialize, Deserialize)]
881#[serde(untagged)]
882pub enum ListCallError {
883    UnknownValue(serde_json::Value),
884}
885
886/// struct for typed errors of method [`list_call_event`]
887#[derive(Debug, Clone, Serialize, Deserialize)]
888#[serde(untagged)]
889pub enum ListCallEventError {
890    UnknownValue(serde_json::Value),
891}
892
893/// struct for typed errors of method [`list_call_notification`]
894#[derive(Debug, Clone, Serialize, Deserialize)]
895#[serde(untagged)]
896pub enum ListCallNotificationError {
897    UnknownValue(serde_json::Value),
898}
899
900/// struct for typed errors of method [`list_call_recording`]
901#[derive(Debug, Clone, Serialize, Deserialize)]
902#[serde(untagged)]
903pub enum ListCallRecordingError {
904    UnknownValue(serde_json::Value),
905}
906
907/// struct for typed errors of method [`list_conference`]
908#[derive(Debug, Clone, Serialize, Deserialize)]
909#[serde(untagged)]
910pub enum ListConferenceError {
911    UnknownValue(serde_json::Value),
912}
913
914/// struct for typed errors of method [`list_conference_recording`]
915#[derive(Debug, Clone, Serialize, Deserialize)]
916#[serde(untagged)]
917pub enum ListConferenceRecordingError {
918    UnknownValue(serde_json::Value),
919}
920
921/// struct for typed errors of method [`list_connect_app`]
922#[derive(Debug, Clone, Serialize, Deserialize)]
923#[serde(untagged)]
924pub enum ListConnectAppError {
925    UnknownValue(serde_json::Value),
926}
927
928/// struct for typed errors of method [`list_dependent_phone_number`]
929#[derive(Debug, Clone, Serialize, Deserialize)]
930#[serde(untagged)]
931pub enum ListDependentPhoneNumberError {
932    UnknownValue(serde_json::Value),
933}
934
935/// struct for typed errors of method [`list_incoming_phone_number`]
936#[derive(Debug, Clone, Serialize, Deserialize)]
937#[serde(untagged)]
938pub enum ListIncomingPhoneNumberError {
939    UnknownValue(serde_json::Value),
940}
941
942/// struct for typed errors of method [`list_incoming_phone_number_assigned_add_on`]
943#[derive(Debug, Clone, Serialize, Deserialize)]
944#[serde(untagged)]
945pub enum ListIncomingPhoneNumberAssignedAddOnError {
946    UnknownValue(serde_json::Value),
947}
948
949/// struct for typed errors of method [`list_incoming_phone_number_assigned_add_on_extension`]
950#[derive(Debug, Clone, Serialize, Deserialize)]
951#[serde(untagged)]
952pub enum ListIncomingPhoneNumberAssignedAddOnExtensionError {
953    UnknownValue(serde_json::Value),
954}
955
956/// struct for typed errors of method [`list_incoming_phone_number_local`]
957#[derive(Debug, Clone, Serialize, Deserialize)]
958#[serde(untagged)]
959pub enum ListIncomingPhoneNumberLocalError {
960    UnknownValue(serde_json::Value),
961}
962
963/// struct for typed errors of method [`list_incoming_phone_number_mobile`]
964#[derive(Debug, Clone, Serialize, Deserialize)]
965#[serde(untagged)]
966pub enum ListIncomingPhoneNumberMobileError {
967    UnknownValue(serde_json::Value),
968}
969
970/// struct for typed errors of method [`list_incoming_phone_number_toll_free`]
971#[derive(Debug, Clone, Serialize, Deserialize)]
972#[serde(untagged)]
973pub enum ListIncomingPhoneNumberTollFreeError {
974    UnknownValue(serde_json::Value),
975}
976
977/// struct for typed errors of method [`list_key`]
978#[derive(Debug, Clone, Serialize, Deserialize)]
979#[serde(untagged)]
980pub enum ListKeyError {
981    UnknownValue(serde_json::Value),
982}
983
984/// struct for typed errors of method [`list_media`]
985#[derive(Debug, Clone, Serialize, Deserialize)]
986#[serde(untagged)]
987pub enum ListMediaError {
988    UnknownValue(serde_json::Value),
989}
990
991/// struct for typed errors of method [`list_member`]
992#[derive(Debug, Clone, Serialize, Deserialize)]
993#[serde(untagged)]
994pub enum ListMemberError {
995    UnknownValue(serde_json::Value),
996}
997
998/// struct for typed errors of method [`list_message`]
999#[derive(Debug, Clone, Serialize, Deserialize)]
1000#[serde(untagged)]
1001pub enum ListMessageError {
1002    UnknownValue(serde_json::Value),
1003}
1004
1005/// struct for typed errors of method [`list_notification`]
1006#[derive(Debug, Clone, Serialize, Deserialize)]
1007#[serde(untagged)]
1008pub enum ListNotificationError {
1009    UnknownValue(serde_json::Value),
1010}
1011
1012/// struct for typed errors of method [`list_outgoing_caller_id`]
1013#[derive(Debug, Clone, Serialize, Deserialize)]
1014#[serde(untagged)]
1015pub enum ListOutgoingCallerIdError {
1016    UnknownValue(serde_json::Value),
1017}
1018
1019/// struct for typed errors of method [`list_participant`]
1020#[derive(Debug, Clone, Serialize, Deserialize)]
1021#[serde(untagged)]
1022pub enum ListParticipantError {
1023    UnknownValue(serde_json::Value),
1024}
1025
1026/// struct for typed errors of method [`list_queue`]
1027#[derive(Debug, Clone, Serialize, Deserialize)]
1028#[serde(untagged)]
1029pub enum ListQueueError {
1030    UnknownValue(serde_json::Value),
1031}
1032
1033/// struct for typed errors of method [`list_recording`]
1034#[derive(Debug, Clone, Serialize, Deserialize)]
1035#[serde(untagged)]
1036pub enum ListRecordingError {
1037    UnknownValue(serde_json::Value),
1038}
1039
1040/// struct for typed errors of method [`list_recording_add_on_result`]
1041#[derive(Debug, Clone, Serialize, Deserialize)]
1042#[serde(untagged)]
1043pub enum ListRecordingAddOnResultError {
1044    UnknownValue(serde_json::Value),
1045}
1046
1047/// struct for typed errors of method [`list_recording_add_on_result_payload`]
1048#[derive(Debug, Clone, Serialize, Deserialize)]
1049#[serde(untagged)]
1050pub enum ListRecordingAddOnResultPayloadError {
1051    UnknownValue(serde_json::Value),
1052}
1053
1054/// struct for typed errors of method [`list_recording_transcription`]
1055#[derive(Debug, Clone, Serialize, Deserialize)]
1056#[serde(untagged)]
1057pub enum ListRecordingTranscriptionError {
1058    UnknownValue(serde_json::Value),
1059}
1060
1061/// struct for typed errors of method [`list_short_code`]
1062#[derive(Debug, Clone, Serialize, Deserialize)]
1063#[serde(untagged)]
1064pub enum ListShortCodeError {
1065    UnknownValue(serde_json::Value),
1066}
1067
1068/// struct for typed errors of method [`list_signing_key`]
1069#[derive(Debug, Clone, Serialize, Deserialize)]
1070#[serde(untagged)]
1071pub enum ListSigningKeyError {
1072    UnknownValue(serde_json::Value),
1073}
1074
1075/// struct for typed errors of method [`list_sip_auth_calls_credential_list_mapping`]
1076#[derive(Debug, Clone, Serialize, Deserialize)]
1077#[serde(untagged)]
1078pub enum ListSipAuthCallsCredentialListMappingError {
1079    UnknownValue(serde_json::Value),
1080}
1081
1082/// struct for typed errors of method [`list_sip_auth_calls_ip_access_control_list_mapping`]
1083#[derive(Debug, Clone, Serialize, Deserialize)]
1084#[serde(untagged)]
1085pub enum ListSipAuthCallsIpAccessControlListMappingError {
1086    UnknownValue(serde_json::Value),
1087}
1088
1089/// struct for typed errors of method [`list_sip_auth_registrations_credential_list_mapping`]
1090#[derive(Debug, Clone, Serialize, Deserialize)]
1091#[serde(untagged)]
1092pub enum ListSipAuthRegistrationsCredentialListMappingError {
1093    UnknownValue(serde_json::Value),
1094}
1095
1096/// struct for typed errors of method [`list_sip_credential`]
1097#[derive(Debug, Clone, Serialize, Deserialize)]
1098#[serde(untagged)]
1099pub enum ListSipCredentialError {
1100    UnknownValue(serde_json::Value),
1101}
1102
1103/// struct for typed errors of method [`list_sip_credential_list`]
1104#[derive(Debug, Clone, Serialize, Deserialize)]
1105#[serde(untagged)]
1106pub enum ListSipCredentialListError {
1107    UnknownValue(serde_json::Value),
1108}
1109
1110/// struct for typed errors of method [`list_sip_credential_list_mapping`]
1111#[derive(Debug, Clone, Serialize, Deserialize)]
1112#[serde(untagged)]
1113pub enum ListSipCredentialListMappingError {
1114    UnknownValue(serde_json::Value),
1115}
1116
1117/// struct for typed errors of method [`list_sip_domain`]
1118#[derive(Debug, Clone, Serialize, Deserialize)]
1119#[serde(untagged)]
1120pub enum ListSipDomainError {
1121    UnknownValue(serde_json::Value),
1122}
1123
1124/// struct for typed errors of method [`list_sip_ip_access_control_list`]
1125#[derive(Debug, Clone, Serialize, Deserialize)]
1126#[serde(untagged)]
1127pub enum ListSipIpAccessControlListError {
1128    UnknownValue(serde_json::Value),
1129}
1130
1131/// struct for typed errors of method [`list_sip_ip_access_control_list_mapping`]
1132#[derive(Debug, Clone, Serialize, Deserialize)]
1133#[serde(untagged)]
1134pub enum ListSipIpAccessControlListMappingError {
1135    UnknownValue(serde_json::Value),
1136}
1137
1138/// struct for typed errors of method [`list_sip_ip_address`]
1139#[derive(Debug, Clone, Serialize, Deserialize)]
1140#[serde(untagged)]
1141pub enum ListSipIpAddressError {
1142    UnknownValue(serde_json::Value),
1143}
1144
1145/// struct for typed errors of method [`list_transcription`]
1146#[derive(Debug, Clone, Serialize, Deserialize)]
1147#[serde(untagged)]
1148pub enum ListTranscriptionError {
1149    UnknownValue(serde_json::Value),
1150}
1151
1152/// struct for typed errors of method [`list_usage_record`]
1153#[derive(Debug, Clone, Serialize, Deserialize)]
1154#[serde(untagged)]
1155pub enum ListUsageRecordError {
1156    UnknownValue(serde_json::Value),
1157}
1158
1159/// struct for typed errors of method [`list_usage_record_all_time`]
1160#[derive(Debug, Clone, Serialize, Deserialize)]
1161#[serde(untagged)]
1162pub enum ListUsageRecordAllTimeError {
1163    UnknownValue(serde_json::Value),
1164}
1165
1166/// struct for typed errors of method [`list_usage_record_daily`]
1167#[derive(Debug, Clone, Serialize, Deserialize)]
1168#[serde(untagged)]
1169pub enum ListUsageRecordDailyError {
1170    UnknownValue(serde_json::Value),
1171}
1172
1173/// struct for typed errors of method [`list_usage_record_last_month`]
1174#[derive(Debug, Clone, Serialize, Deserialize)]
1175#[serde(untagged)]
1176pub enum ListUsageRecordLastMonthError {
1177    UnknownValue(serde_json::Value),
1178}
1179
1180/// struct for typed errors of method [`list_usage_record_monthly`]
1181#[derive(Debug, Clone, Serialize, Deserialize)]
1182#[serde(untagged)]
1183pub enum ListUsageRecordMonthlyError {
1184    UnknownValue(serde_json::Value),
1185}
1186
1187/// struct for typed errors of method [`list_usage_record_this_month`]
1188#[derive(Debug, Clone, Serialize, Deserialize)]
1189#[serde(untagged)]
1190pub enum ListUsageRecordThisMonthError {
1191    UnknownValue(serde_json::Value),
1192}
1193
1194/// struct for typed errors of method [`list_usage_record_today`]
1195#[derive(Debug, Clone, Serialize, Deserialize)]
1196#[serde(untagged)]
1197pub enum ListUsageRecordTodayError {
1198    UnknownValue(serde_json::Value),
1199}
1200
1201/// struct for typed errors of method [`list_usage_record_yearly`]
1202#[derive(Debug, Clone, Serialize, Deserialize)]
1203#[serde(untagged)]
1204pub enum ListUsageRecordYearlyError {
1205    UnknownValue(serde_json::Value),
1206}
1207
1208/// struct for typed errors of method [`list_usage_record_yesterday`]
1209#[derive(Debug, Clone, Serialize, Deserialize)]
1210#[serde(untagged)]
1211pub enum ListUsageRecordYesterdayError {
1212    UnknownValue(serde_json::Value),
1213}
1214
1215/// struct for typed errors of method [`list_usage_trigger`]
1216#[derive(Debug, Clone, Serialize, Deserialize)]
1217#[serde(untagged)]
1218pub enum ListUsageTriggerError {
1219    UnknownValue(serde_json::Value),
1220}
1221
1222/// struct for typed errors of method [`update_account`]
1223#[derive(Debug, Clone, Serialize, Deserialize)]
1224#[serde(untagged)]
1225pub enum UpdateAccountError {
1226    UnknownValue(serde_json::Value),
1227}
1228
1229/// struct for typed errors of method [`update_address`]
1230#[derive(Debug, Clone, Serialize, Deserialize)]
1231#[serde(untagged)]
1232pub enum UpdateAddressError {
1233    UnknownValue(serde_json::Value),
1234}
1235
1236/// struct for typed errors of method [`update_application`]
1237#[derive(Debug, Clone, Serialize, Deserialize)]
1238#[serde(untagged)]
1239pub enum UpdateApplicationError {
1240    UnknownValue(serde_json::Value),
1241}
1242
1243/// struct for typed errors of method [`update_call`]
1244#[derive(Debug, Clone, Serialize, Deserialize)]
1245#[serde(untagged)]
1246pub enum UpdateCallError {
1247    UnknownValue(serde_json::Value),
1248}
1249
1250/// struct for typed errors of method [`update_call_feedback`]
1251#[derive(Debug, Clone, Serialize, Deserialize)]
1252#[serde(untagged)]
1253pub enum UpdateCallFeedbackError {
1254    UnknownValue(serde_json::Value),
1255}
1256
1257/// struct for typed errors of method [`update_call_recording`]
1258#[derive(Debug, Clone, Serialize, Deserialize)]
1259#[serde(untagged)]
1260pub enum UpdateCallRecordingError {
1261    UnknownValue(serde_json::Value),
1262}
1263
1264/// struct for typed errors of method [`update_conference`]
1265#[derive(Debug, Clone, Serialize, Deserialize)]
1266#[serde(untagged)]
1267pub enum UpdateConferenceError {
1268    UnknownValue(serde_json::Value),
1269}
1270
1271/// struct for typed errors of method [`update_conference_recording`]
1272#[derive(Debug, Clone, Serialize, Deserialize)]
1273#[serde(untagged)]
1274pub enum UpdateConferenceRecordingError {
1275    UnknownValue(serde_json::Value),
1276}
1277
1278/// struct for typed errors of method [`update_connect_app`]
1279#[derive(Debug, Clone, Serialize, Deserialize)]
1280#[serde(untagged)]
1281pub enum UpdateConnectAppError {
1282    UnknownValue(serde_json::Value),
1283}
1284
1285/// struct for typed errors of method [`update_incoming_phone_number`]
1286#[derive(Debug, Clone, Serialize, Deserialize)]
1287#[serde(untagged)]
1288pub enum UpdateIncomingPhoneNumberError {
1289    UnknownValue(serde_json::Value),
1290}
1291
1292/// struct for typed errors of method [`update_key`]
1293#[derive(Debug, Clone, Serialize, Deserialize)]
1294#[serde(untagged)]
1295pub enum UpdateKeyError {
1296    UnknownValue(serde_json::Value),
1297}
1298
1299/// struct for typed errors of method [`update_member`]
1300#[derive(Debug, Clone, Serialize, Deserialize)]
1301#[serde(untagged)]
1302pub enum UpdateMemberError {
1303    UnknownValue(serde_json::Value),
1304}
1305
1306/// struct for typed errors of method [`update_message`]
1307#[derive(Debug, Clone, Serialize, Deserialize)]
1308#[serde(untagged)]
1309pub enum UpdateMessageError {
1310    UnknownValue(serde_json::Value),
1311}
1312
1313/// struct for typed errors of method [`update_outgoing_caller_id`]
1314#[derive(Debug, Clone, Serialize, Deserialize)]
1315#[serde(untagged)]
1316pub enum UpdateOutgoingCallerIdError {
1317    UnknownValue(serde_json::Value),
1318}
1319
1320/// struct for typed errors of method [`update_participant`]
1321#[derive(Debug, Clone, Serialize, Deserialize)]
1322#[serde(untagged)]
1323pub enum UpdateParticipantError {
1324    UnknownValue(serde_json::Value),
1325}
1326
1327/// struct for typed errors of method [`update_payments`]
1328#[derive(Debug, Clone, Serialize, Deserialize)]
1329#[serde(untagged)]
1330pub enum UpdatePaymentsError {
1331    UnknownValue(serde_json::Value),
1332}
1333
1334/// struct for typed errors of method [`update_queue`]
1335#[derive(Debug, Clone, Serialize, Deserialize)]
1336#[serde(untagged)]
1337pub enum UpdateQueueError {
1338    UnknownValue(serde_json::Value),
1339}
1340
1341/// struct for typed errors of method [`update_short_code`]
1342#[derive(Debug, Clone, Serialize, Deserialize)]
1343#[serde(untagged)]
1344pub enum UpdateShortCodeError {
1345    UnknownValue(serde_json::Value),
1346}
1347
1348/// struct for typed errors of method [`update_signing_key`]
1349#[derive(Debug, Clone, Serialize, Deserialize)]
1350#[serde(untagged)]
1351pub enum UpdateSigningKeyError {
1352    UnknownValue(serde_json::Value),
1353}
1354
1355/// struct for typed errors of method [`update_sip_credential`]
1356#[derive(Debug, Clone, Serialize, Deserialize)]
1357#[serde(untagged)]
1358pub enum UpdateSipCredentialError {
1359    UnknownValue(serde_json::Value),
1360}
1361
1362/// struct for typed errors of method [`update_sip_credential_list`]
1363#[derive(Debug, Clone, Serialize, Deserialize)]
1364#[serde(untagged)]
1365pub enum UpdateSipCredentialListError {
1366    UnknownValue(serde_json::Value),
1367}
1368
1369/// struct for typed errors of method [`update_sip_domain`]
1370#[derive(Debug, Clone, Serialize, Deserialize)]
1371#[serde(untagged)]
1372pub enum UpdateSipDomainError {
1373    UnknownValue(serde_json::Value),
1374}
1375
1376/// struct for typed errors of method [`update_sip_ip_access_control_list`]
1377#[derive(Debug, Clone, Serialize, Deserialize)]
1378#[serde(untagged)]
1379pub enum UpdateSipIpAccessControlListError {
1380    UnknownValue(serde_json::Value),
1381}
1382
1383/// struct for typed errors of method [`update_sip_ip_address`]
1384#[derive(Debug, Clone, Serialize, Deserialize)]
1385#[serde(untagged)]
1386pub enum UpdateSipIpAddressError {
1387    UnknownValue(serde_json::Value),
1388}
1389
1390/// struct for typed errors of method [`update_siprec`]
1391#[derive(Debug, Clone, Serialize, Deserialize)]
1392#[serde(untagged)]
1393pub enum UpdateSiprecError {
1394    UnknownValue(serde_json::Value),
1395}
1396
1397/// struct for typed errors of method [`update_stream`]
1398#[derive(Debug, Clone, Serialize, Deserialize)]
1399#[serde(untagged)]
1400pub enum UpdateStreamError {
1401    UnknownValue(serde_json::Value),
1402}
1403
1404/// struct for typed errors of method [`update_usage_trigger`]
1405#[derive(Debug, Clone, Serialize, Deserialize)]
1406#[serde(untagged)]
1407pub enum UpdateUsageTriggerError {
1408    UnknownValue(serde_json::Value),
1409}
1410
1411
1412/// Create a new Twilio Subaccount from the account making the request
1413pub async fn create_account(configuration: &configuration::Configuration, friendly_name: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccount, Error<CreateAccountError>> {
1414    let local_var_configuration = configuration;
1415
1416    let local_var_client = &local_var_configuration.client;
1417
1418    let local_var_uri_str = format!("{}/2010-04-01/Accounts.json", local_var_configuration.base_path);
1419    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1420
1421    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1422        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1423    }
1424    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
1425        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
1426    };
1427    let mut local_var_form_params = std::collections::HashMap::new();
1428    if let Some(local_var_param_value) = friendly_name {
1429        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
1430    }
1431    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
1432
1433    let local_var_req = local_var_req_builder.build()?;
1434    let local_var_resp = local_var_client.execute(local_var_req).await?;
1435
1436    let local_var_status = local_var_resp.status();
1437    let local_var_content = local_var_resp.text().await?;
1438
1439    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1440        serde_json::from_str(&local_var_content).map_err(Error::from)
1441    } else {
1442        let local_var_entity: Option<CreateAccountError> = serde_json::from_str(&local_var_content).ok();
1443        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1444        Err(Error::ResponseError(local_var_error))
1445    }
1446}
1447
1448/// 
1449pub async fn create_address(configuration: &configuration::Configuration, account_sid: &str, customer_name: &str, street: &str, city: &str, region: &str, postal_code: &str, iso_country: &str, friendly_name: Option<&str>, emergency_enabled: Option<bool>, auto_correct_address: Option<bool>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodAddress, Error<CreateAddressError>> {
1450    let local_var_configuration = configuration;
1451
1452    let local_var_client = &local_var_configuration.client;
1453
1454    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Addresses.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
1455    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1456
1457    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1458        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1459    }
1460    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
1461        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
1462    };
1463    let mut local_var_form_params = std::collections::HashMap::new();
1464    local_var_form_params.insert("CustomerName", customer_name.to_string());
1465    local_var_form_params.insert("Street", street.to_string());
1466    local_var_form_params.insert("City", city.to_string());
1467    local_var_form_params.insert("Region", region.to_string());
1468    local_var_form_params.insert("PostalCode", postal_code.to_string());
1469    local_var_form_params.insert("IsoCountry", iso_country.to_string());
1470    if let Some(local_var_param_value) = friendly_name {
1471        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
1472    }
1473    if let Some(local_var_param_value) = emergency_enabled {
1474        local_var_form_params.insert("EmergencyEnabled", local_var_param_value.to_string());
1475    }
1476    if let Some(local_var_param_value) = auto_correct_address {
1477        local_var_form_params.insert("AutoCorrectAddress", local_var_param_value.to_string());
1478    }
1479    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
1480
1481    let local_var_req = local_var_req_builder.build()?;
1482    let local_var_resp = local_var_client.execute(local_var_req).await?;
1483
1484    let local_var_status = local_var_resp.status();
1485    let local_var_content = local_var_resp.text().await?;
1486
1487    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1488        serde_json::from_str(&local_var_content).map_err(Error::from)
1489    } else {
1490        let local_var_entity: Option<CreateAddressError> = serde_json::from_str(&local_var_content).ok();
1491        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1492        Err(Error::ResponseError(local_var_error))
1493    }
1494}
1495
1496/// Create a new application within your account
1497pub async fn create_application(configuration: &configuration::Configuration, account_sid: &str, api_version: Option<&str>, voice_url: Option<&str>, voice_method: Option<&str>, voice_fallback_url: Option<&str>, voice_fallback_method: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, voice_caller_id_lookup: Option<bool>, sms_url: Option<&str>, sms_method: Option<&str>, sms_fallback_url: Option<&str>, sms_fallback_method: Option<&str>, sms_status_callback: Option<&str>, message_status_callback: Option<&str>, friendly_name: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodApplication, Error<CreateApplicationError>> {
1498    let local_var_configuration = configuration;
1499
1500    let local_var_client = &local_var_configuration.client;
1501
1502    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
1503    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1504
1505    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1506        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1507    }
1508    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
1509        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
1510    };
1511    let mut local_var_form_params = std::collections::HashMap::new();
1512    if let Some(local_var_param_value) = api_version {
1513        local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
1514    }
1515    if let Some(local_var_param_value) = voice_url {
1516        local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
1517    }
1518    if let Some(local_var_param_value) = voice_method {
1519        local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
1520    }
1521    if let Some(local_var_param_value) = voice_fallback_url {
1522        local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
1523    }
1524    if let Some(local_var_param_value) = voice_fallback_method {
1525        local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
1526    }
1527    if let Some(local_var_param_value) = status_callback {
1528        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
1529    }
1530    if let Some(local_var_param_value) = status_callback_method {
1531        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
1532    }
1533    if let Some(local_var_param_value) = voice_caller_id_lookup {
1534        local_var_form_params.insert("VoiceCallerIdLookup", local_var_param_value.to_string());
1535    }
1536    if let Some(local_var_param_value) = sms_url {
1537        local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
1538    }
1539    if let Some(local_var_param_value) = sms_method {
1540        local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
1541    }
1542    if let Some(local_var_param_value) = sms_fallback_url {
1543        local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
1544    }
1545    if let Some(local_var_param_value) = sms_fallback_method {
1546        local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
1547    }
1548    if let Some(local_var_param_value) = sms_status_callback {
1549        local_var_form_params.insert("SmsStatusCallback", local_var_param_value.to_string());
1550    }
1551    if let Some(local_var_param_value) = message_status_callback {
1552        local_var_form_params.insert("MessageStatusCallback", local_var_param_value.to_string());
1553    }
1554    if let Some(local_var_param_value) = friendly_name {
1555        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
1556    }
1557    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
1558
1559    let local_var_req = local_var_req_builder.build()?;
1560    let local_var_resp = local_var_client.execute(local_var_req).await?;
1561
1562    let local_var_status = local_var_resp.status();
1563    let local_var_content = local_var_resp.text().await?;
1564
1565    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1566        serde_json::from_str(&local_var_content).map_err(Error::from)
1567    } else {
1568        let local_var_entity: Option<CreateApplicationError> = serde_json::from_str(&local_var_content).ok();
1569        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1570        Err(Error::ResponseError(local_var_error))
1571    }
1572}
1573
1574/// Create a new outgoing call to phones, SIP-enabled endpoints or Twilio Client connections
1575pub async fn create_call(configuration: &configuration::Configuration, account_sid: &str, to: &str, from: &str, method: Option<&str>, fallback_url: Option<&str>, fallback_method: Option<&str>, status_callback: Option<&str>, status_callback_event: Option<Vec<String>>, status_callback_method: Option<&str>, send_digits: Option<&str>, timeout: Option<i32>, record: Option<bool>, recording_channels: Option<&str>, recording_status_callback: Option<&str>, recording_status_callback_method: Option<&str>, sip_auth_username: Option<&str>, sip_auth_password: Option<&str>, machine_detection: Option<&str>, machine_detection_timeout: Option<i32>, recording_status_callback_event: Option<Vec<String>>, trim: Option<&str>, caller_id: Option<&str>, machine_detection_speech_threshold: Option<i32>, machine_detection_speech_end_threshold: Option<i32>, machine_detection_silence_timeout: Option<i32>, async_amd: Option<&str>, async_amd_status_callback: Option<&str>, async_amd_status_callback_method: Option<&str>, byoc: Option<&str>, call_reason: Option<&str>, call_token: Option<&str>, recording_track: Option<&str>, time_limit: Option<i32>, url: Option<&str>, twiml: Option<&str>, application_sid: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCall, Error<CreateCallError>> {
1576    let local_var_configuration = configuration;
1577
1578    let local_var_client = &local_var_configuration.client;
1579
1580    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
1581    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1582
1583    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1584        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1585    }
1586    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
1587        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
1588    };
1589    let mut local_var_form_params = std::collections::HashMap::new();
1590    local_var_form_params.insert("To", to.to_string());
1591    local_var_form_params.insert("From", from.to_string());
1592    if let Some(local_var_param_value) = method {
1593        local_var_form_params.insert("Method", local_var_param_value.to_string());
1594    }
1595    if let Some(local_var_param_value) = fallback_url {
1596        local_var_form_params.insert("FallbackUrl", local_var_param_value.to_string());
1597    }
1598    if let Some(local_var_param_value) = fallback_method {
1599        local_var_form_params.insert("FallbackMethod", local_var_param_value.to_string());
1600    }
1601    if let Some(local_var_param_value) = status_callback {
1602        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
1603    }
1604    if let Some(local_var_param_value) = status_callback_event {
1605        local_var_form_params.insert("StatusCallbackEvent", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
1606    }
1607    if let Some(local_var_param_value) = status_callback_method {
1608        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
1609    }
1610    if let Some(local_var_param_value) = send_digits {
1611        local_var_form_params.insert("SendDigits", local_var_param_value.to_string());
1612    }
1613    if let Some(local_var_param_value) = timeout {
1614        local_var_form_params.insert("Timeout", local_var_param_value.to_string());
1615    }
1616    if let Some(local_var_param_value) = record {
1617        local_var_form_params.insert("Record", local_var_param_value.to_string());
1618    }
1619    if let Some(local_var_param_value) = recording_channels {
1620        local_var_form_params.insert("RecordingChannels", local_var_param_value.to_string());
1621    }
1622    if let Some(local_var_param_value) = recording_status_callback {
1623        local_var_form_params.insert("RecordingStatusCallback", local_var_param_value.to_string());
1624    }
1625    if let Some(local_var_param_value) = recording_status_callback_method {
1626        local_var_form_params.insert("RecordingStatusCallbackMethod", local_var_param_value.to_string());
1627    }
1628    if let Some(local_var_param_value) = sip_auth_username {
1629        local_var_form_params.insert("SipAuthUsername", local_var_param_value.to_string());
1630    }
1631    if let Some(local_var_param_value) = sip_auth_password {
1632        local_var_form_params.insert("SipAuthPassword", local_var_param_value.to_string());
1633    }
1634    if let Some(local_var_param_value) = machine_detection {
1635        local_var_form_params.insert("MachineDetection", local_var_param_value.to_string());
1636    }
1637    if let Some(local_var_param_value) = machine_detection_timeout {
1638        local_var_form_params.insert("MachineDetectionTimeout", local_var_param_value.to_string());
1639    }
1640    if let Some(local_var_param_value) = recording_status_callback_event {
1641        local_var_form_params.insert("RecordingStatusCallbackEvent", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
1642    }
1643    if let Some(local_var_param_value) = trim {
1644        local_var_form_params.insert("Trim", local_var_param_value.to_string());
1645    }
1646    if let Some(local_var_param_value) = caller_id {
1647        local_var_form_params.insert("CallerId", local_var_param_value.to_string());
1648    }
1649    if let Some(local_var_param_value) = machine_detection_speech_threshold {
1650        local_var_form_params.insert("MachineDetectionSpeechThreshold", local_var_param_value.to_string());
1651    }
1652    if let Some(local_var_param_value) = machine_detection_speech_end_threshold {
1653        local_var_form_params.insert("MachineDetectionSpeechEndThreshold", local_var_param_value.to_string());
1654    }
1655    if let Some(local_var_param_value) = machine_detection_silence_timeout {
1656        local_var_form_params.insert("MachineDetectionSilenceTimeout", local_var_param_value.to_string());
1657    }
1658    if let Some(local_var_param_value) = async_amd {
1659        local_var_form_params.insert("AsyncAmd", local_var_param_value.to_string());
1660    }
1661    if let Some(local_var_param_value) = async_amd_status_callback {
1662        local_var_form_params.insert("AsyncAmdStatusCallback", local_var_param_value.to_string());
1663    }
1664    if let Some(local_var_param_value) = async_amd_status_callback_method {
1665        local_var_form_params.insert("AsyncAmdStatusCallbackMethod", local_var_param_value.to_string());
1666    }
1667    if let Some(local_var_param_value) = byoc {
1668        local_var_form_params.insert("Byoc", local_var_param_value.to_string());
1669    }
1670    if let Some(local_var_param_value) = call_reason {
1671        local_var_form_params.insert("CallReason", local_var_param_value.to_string());
1672    }
1673    if let Some(local_var_param_value) = call_token {
1674        local_var_form_params.insert("CallToken", local_var_param_value.to_string());
1675    }
1676    if let Some(local_var_param_value) = recording_track {
1677        local_var_form_params.insert("RecordingTrack", local_var_param_value.to_string());
1678    }
1679    if let Some(local_var_param_value) = time_limit {
1680        local_var_form_params.insert("TimeLimit", local_var_param_value.to_string());
1681    }
1682    if let Some(local_var_param_value) = url {
1683        local_var_form_params.insert("Url", local_var_param_value.to_string());
1684    }
1685    if let Some(local_var_param_value) = twiml {
1686        local_var_form_params.insert("Twiml", local_var_param_value.to_string());
1687    }
1688    if let Some(local_var_param_value) = application_sid {
1689        local_var_form_params.insert("ApplicationSid", local_var_param_value.to_string());
1690    }
1691    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
1692
1693    let local_var_req = local_var_req_builder.build()?;
1694    let local_var_resp = local_var_client.execute(local_var_req).await?;
1695
1696    let local_var_status = local_var_resp.status();
1697    let local_var_content = local_var_resp.text().await?;
1698
1699    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1700        serde_json::from_str(&local_var_content).map_err(Error::from)
1701    } else {
1702        let local_var_entity: Option<CreateCallError> = serde_json::from_str(&local_var_content).ok();
1703        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1704        Err(Error::ResponseError(local_var_error))
1705    }
1706}
1707
1708/// Create a FeedbackSummary resource for a call
1709pub async fn create_call_feedback_summary(configuration: &configuration::Configuration, account_sid: &str, start_date: String, end_date: String, include_subaccounts: Option<bool>, status_callback: Option<&str>, status_callback_method: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodCallFeedbackSummary, Error<CreateCallFeedbackSummaryError>> {
1710    let local_var_configuration = configuration;
1711
1712    let local_var_client = &local_var_configuration.client;
1713
1714    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/FeedbackSummary.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
1715    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1716
1717    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1718        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1719    }
1720    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
1721        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
1722    };
1723    let mut local_var_form_params = std::collections::HashMap::new();
1724    local_var_form_params.insert("StartDate", start_date.to_string());
1725    local_var_form_params.insert("EndDate", end_date.to_string());
1726    if let Some(local_var_param_value) = include_subaccounts {
1727        local_var_form_params.insert("IncludeSubaccounts", local_var_param_value.to_string());
1728    }
1729    if let Some(local_var_param_value) = status_callback {
1730        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
1731    }
1732    if let Some(local_var_param_value) = status_callback_method {
1733        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
1734    }
1735    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
1736
1737    let local_var_req = local_var_req_builder.build()?;
1738    let local_var_resp = local_var_client.execute(local_var_req).await?;
1739
1740    let local_var_status = local_var_resp.status();
1741    let local_var_content = local_var_resp.text().await?;
1742
1743    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1744        serde_json::from_str(&local_var_content).map_err(Error::from)
1745    } else {
1746        let local_var_entity: Option<CreateCallFeedbackSummaryError> = serde_json::from_str(&local_var_content).ok();
1747        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1748        Err(Error::ResponseError(local_var_error))
1749    }
1750}
1751
1752/// Create a recording for the call
1753pub async fn create_call_recording(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, recording_status_callback_event: Option<Vec<String>>, recording_status_callback: Option<&str>, recording_status_callback_method: Option<&str>, trim: Option<&str>, recording_channels: Option<&str>, recording_track: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodCallRecording, Error<CreateCallRecordingError>> {
1754    let local_var_configuration = configuration;
1755
1756    let local_var_client = &local_var_configuration.client;
1757
1758    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Recordings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
1759    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1760
1761    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1762        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1763    }
1764    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
1765        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
1766    };
1767    let mut local_var_form_params = std::collections::HashMap::new();
1768    if let Some(local_var_param_value) = recording_status_callback_event {
1769        local_var_form_params.insert("RecordingStatusCallbackEvent", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
1770    }
1771    if let Some(local_var_param_value) = recording_status_callback {
1772        local_var_form_params.insert("RecordingStatusCallback", local_var_param_value.to_string());
1773    }
1774    if let Some(local_var_param_value) = recording_status_callback_method {
1775        local_var_form_params.insert("RecordingStatusCallbackMethod", local_var_param_value.to_string());
1776    }
1777    if let Some(local_var_param_value) = trim {
1778        local_var_form_params.insert("Trim", local_var_param_value.to_string());
1779    }
1780    if let Some(local_var_param_value) = recording_channels {
1781        local_var_form_params.insert("RecordingChannels", local_var_param_value.to_string());
1782    }
1783    if let Some(local_var_param_value) = recording_track {
1784        local_var_form_params.insert("RecordingTrack", local_var_param_value.to_string());
1785    }
1786    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
1787
1788    let local_var_req = local_var_req_builder.build()?;
1789    let local_var_resp = local_var_client.execute(local_var_req).await?;
1790
1791    let local_var_status = local_var_resp.status();
1792    let local_var_content = local_var_resp.text().await?;
1793
1794    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1795        serde_json::from_str(&local_var_content).map_err(Error::from)
1796    } else {
1797        let local_var_entity: Option<CreateCallRecordingError> = serde_json::from_str(&local_var_content).ok();
1798        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1799        Err(Error::ResponseError(local_var_error))
1800    }
1801}
1802
1803/// Purchase a phone-number for the account.
1804pub async fn create_incoming_phone_number(configuration: &configuration::Configuration, account_sid: &str, api_version: Option<&str>, friendly_name: Option<&str>, sms_application_sid: Option<&str>, sms_fallback_method: Option<&str>, sms_fallback_url: Option<&str>, sms_method: Option<&str>, sms_url: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, voice_application_sid: Option<&str>, voice_caller_id_lookup: Option<bool>, voice_fallback_method: Option<&str>, voice_fallback_url: Option<&str>, voice_method: Option<&str>, voice_url: Option<&str>, emergency_status: Option<&str>, emergency_address_sid: Option<&str>, trunk_sid: Option<&str>, identity_sid: Option<&str>, address_sid: Option<&str>, voice_receive_mode: Option<&str>, bundle_sid: Option<&str>, phone_number: Option<&str>, area_code: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodIncomingPhoneNumber, Error<CreateIncomingPhoneNumberError>> {
1805    let local_var_configuration = configuration;
1806
1807    let local_var_client = &local_var_configuration.client;
1808
1809    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
1810    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1811
1812    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1813        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1814    }
1815    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
1816        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
1817    };
1818    let mut local_var_form_params = std::collections::HashMap::new();
1819    if let Some(local_var_param_value) = api_version {
1820        local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
1821    }
1822    if let Some(local_var_param_value) = friendly_name {
1823        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
1824    }
1825    if let Some(local_var_param_value) = sms_application_sid {
1826        local_var_form_params.insert("SmsApplicationSid", local_var_param_value.to_string());
1827    }
1828    if let Some(local_var_param_value) = sms_fallback_method {
1829        local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
1830    }
1831    if let Some(local_var_param_value) = sms_fallback_url {
1832        local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
1833    }
1834    if let Some(local_var_param_value) = sms_method {
1835        local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
1836    }
1837    if let Some(local_var_param_value) = sms_url {
1838        local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
1839    }
1840    if let Some(local_var_param_value) = status_callback {
1841        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
1842    }
1843    if let Some(local_var_param_value) = status_callback_method {
1844        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
1845    }
1846    if let Some(local_var_param_value) = voice_application_sid {
1847        local_var_form_params.insert("VoiceApplicationSid", local_var_param_value.to_string());
1848    }
1849    if let Some(local_var_param_value) = voice_caller_id_lookup {
1850        local_var_form_params.insert("VoiceCallerIdLookup", local_var_param_value.to_string());
1851    }
1852    if let Some(local_var_param_value) = voice_fallback_method {
1853        local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
1854    }
1855    if let Some(local_var_param_value) = voice_fallback_url {
1856        local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
1857    }
1858    if let Some(local_var_param_value) = voice_method {
1859        local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
1860    }
1861    if let Some(local_var_param_value) = voice_url {
1862        local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
1863    }
1864    if let Some(local_var_param_value) = emergency_status {
1865        local_var_form_params.insert("EmergencyStatus", local_var_param_value.to_string());
1866    }
1867    if let Some(local_var_param_value) = emergency_address_sid {
1868        local_var_form_params.insert("EmergencyAddressSid", local_var_param_value.to_string());
1869    }
1870    if let Some(local_var_param_value) = trunk_sid {
1871        local_var_form_params.insert("TrunkSid", local_var_param_value.to_string());
1872    }
1873    if let Some(local_var_param_value) = identity_sid {
1874        local_var_form_params.insert("IdentitySid", local_var_param_value.to_string());
1875    }
1876    if let Some(local_var_param_value) = address_sid {
1877        local_var_form_params.insert("AddressSid", local_var_param_value.to_string());
1878    }
1879    if let Some(local_var_param_value) = voice_receive_mode {
1880        local_var_form_params.insert("VoiceReceiveMode", local_var_param_value.to_string());
1881    }
1882    if let Some(local_var_param_value) = bundle_sid {
1883        local_var_form_params.insert("BundleSid", local_var_param_value.to_string());
1884    }
1885    if let Some(local_var_param_value) = phone_number {
1886        local_var_form_params.insert("PhoneNumber", local_var_param_value.to_string());
1887    }
1888    if let Some(local_var_param_value) = area_code {
1889        local_var_form_params.insert("AreaCode", local_var_param_value.to_string());
1890    }
1891    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
1892
1893    let local_var_req = local_var_req_builder.build()?;
1894    let local_var_resp = local_var_client.execute(local_var_req).await?;
1895
1896    let local_var_status = local_var_resp.status();
1897    let local_var_content = local_var_resp.text().await?;
1898
1899    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1900        serde_json::from_str(&local_var_content).map_err(Error::from)
1901    } else {
1902        let local_var_entity: Option<CreateIncomingPhoneNumberError> = serde_json::from_str(&local_var_content).ok();
1903        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1904        Err(Error::ResponseError(local_var_error))
1905    }
1906}
1907
1908/// Assign an Add-on installation to the Number specified.
1909pub async fn create_incoming_phone_number_assigned_add_on(configuration: &configuration::Configuration, account_sid: &str, resource_sid: &str, installed_add_on_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodIncomingPhoneNumberPeriodIncomingPhoneNumberAssignedAddOn, Error<CreateIncomingPhoneNumberAssignedAddOnError>> {
1910    let local_var_configuration = configuration;
1911
1912    let local_var_client = &local_var_configuration.client;
1913
1914    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/{ResourceSid}/AssignedAddOns.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ResourceSid=crate::apis::urlencode(resource_sid));
1915    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1916
1917    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1918        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1919    }
1920    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
1921        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
1922    };
1923    let mut local_var_form_params = std::collections::HashMap::new();
1924    local_var_form_params.insert("InstalledAddOnSid", installed_add_on_sid.to_string());
1925    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
1926
1927    let local_var_req = local_var_req_builder.build()?;
1928    let local_var_resp = local_var_client.execute(local_var_req).await?;
1929
1930    let local_var_status = local_var_resp.status();
1931    let local_var_content = local_var_resp.text().await?;
1932
1933    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
1934        serde_json::from_str(&local_var_content).map_err(Error::from)
1935    } else {
1936        let local_var_entity: Option<CreateIncomingPhoneNumberAssignedAddOnError> = serde_json::from_str(&local_var_content).ok();
1937        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
1938        Err(Error::ResponseError(local_var_error))
1939    }
1940}
1941
1942/// 
1943pub async fn create_incoming_phone_number_local(configuration: &configuration::Configuration, account_sid: &str, phone_number: &str, api_version: Option<&str>, friendly_name: Option<&str>, sms_application_sid: Option<&str>, sms_fallback_method: Option<&str>, sms_fallback_url: Option<&str>, sms_method: Option<&str>, sms_url: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, voice_application_sid: Option<&str>, voice_caller_id_lookup: Option<bool>, voice_fallback_method: Option<&str>, voice_fallback_url: Option<&str>, voice_method: Option<&str>, voice_url: Option<&str>, identity_sid: Option<&str>, address_sid: Option<&str>, emergency_status: Option<&str>, emergency_address_sid: Option<&str>, trunk_sid: Option<&str>, voice_receive_mode: Option<&str>, bundle_sid: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodIncomingPhoneNumberPeriodIncomingPhoneNumberLocal, Error<CreateIncomingPhoneNumberLocalError>> {
1944    let local_var_configuration = configuration;
1945
1946    let local_var_client = &local_var_configuration.client;
1947
1948    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/Local.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
1949    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
1950
1951    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
1952        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
1953    }
1954    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
1955        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
1956    };
1957    let mut local_var_form_params = std::collections::HashMap::new();
1958    local_var_form_params.insert("PhoneNumber", phone_number.to_string());
1959    if let Some(local_var_param_value) = api_version {
1960        local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
1961    }
1962    if let Some(local_var_param_value) = friendly_name {
1963        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
1964    }
1965    if let Some(local_var_param_value) = sms_application_sid {
1966        local_var_form_params.insert("SmsApplicationSid", local_var_param_value.to_string());
1967    }
1968    if let Some(local_var_param_value) = sms_fallback_method {
1969        local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
1970    }
1971    if let Some(local_var_param_value) = sms_fallback_url {
1972        local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
1973    }
1974    if let Some(local_var_param_value) = sms_method {
1975        local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
1976    }
1977    if let Some(local_var_param_value) = sms_url {
1978        local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
1979    }
1980    if let Some(local_var_param_value) = status_callback {
1981        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
1982    }
1983    if let Some(local_var_param_value) = status_callback_method {
1984        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
1985    }
1986    if let Some(local_var_param_value) = voice_application_sid {
1987        local_var_form_params.insert("VoiceApplicationSid", local_var_param_value.to_string());
1988    }
1989    if let Some(local_var_param_value) = voice_caller_id_lookup {
1990        local_var_form_params.insert("VoiceCallerIdLookup", local_var_param_value.to_string());
1991    }
1992    if let Some(local_var_param_value) = voice_fallback_method {
1993        local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
1994    }
1995    if let Some(local_var_param_value) = voice_fallback_url {
1996        local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
1997    }
1998    if let Some(local_var_param_value) = voice_method {
1999        local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
2000    }
2001    if let Some(local_var_param_value) = voice_url {
2002        local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
2003    }
2004    if let Some(local_var_param_value) = identity_sid {
2005        local_var_form_params.insert("IdentitySid", local_var_param_value.to_string());
2006    }
2007    if let Some(local_var_param_value) = address_sid {
2008        local_var_form_params.insert("AddressSid", local_var_param_value.to_string());
2009    }
2010    if let Some(local_var_param_value) = emergency_status {
2011        local_var_form_params.insert("EmergencyStatus", local_var_param_value.to_string());
2012    }
2013    if let Some(local_var_param_value) = emergency_address_sid {
2014        local_var_form_params.insert("EmergencyAddressSid", local_var_param_value.to_string());
2015    }
2016    if let Some(local_var_param_value) = trunk_sid {
2017        local_var_form_params.insert("TrunkSid", local_var_param_value.to_string());
2018    }
2019    if let Some(local_var_param_value) = voice_receive_mode {
2020        local_var_form_params.insert("VoiceReceiveMode", local_var_param_value.to_string());
2021    }
2022    if let Some(local_var_param_value) = bundle_sid {
2023        local_var_form_params.insert("BundleSid", local_var_param_value.to_string());
2024    }
2025    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2026
2027    let local_var_req = local_var_req_builder.build()?;
2028    let local_var_resp = local_var_client.execute(local_var_req).await?;
2029
2030    let local_var_status = local_var_resp.status();
2031    let local_var_content = local_var_resp.text().await?;
2032
2033    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2034        serde_json::from_str(&local_var_content).map_err(Error::from)
2035    } else {
2036        let local_var_entity: Option<CreateIncomingPhoneNumberLocalError> = serde_json::from_str(&local_var_content).ok();
2037        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2038        Err(Error::ResponseError(local_var_error))
2039    }
2040}
2041
2042/// 
2043pub async fn create_incoming_phone_number_mobile(configuration: &configuration::Configuration, account_sid: &str, phone_number: &str, api_version: Option<&str>, friendly_name: Option<&str>, sms_application_sid: Option<&str>, sms_fallback_method: Option<&str>, sms_fallback_url: Option<&str>, sms_method: Option<&str>, sms_url: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, voice_application_sid: Option<&str>, voice_caller_id_lookup: Option<bool>, voice_fallback_method: Option<&str>, voice_fallback_url: Option<&str>, voice_method: Option<&str>, voice_url: Option<&str>, identity_sid: Option<&str>, address_sid: Option<&str>, emergency_status: Option<&str>, emergency_address_sid: Option<&str>, trunk_sid: Option<&str>, voice_receive_mode: Option<&str>, bundle_sid: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodIncomingPhoneNumberPeriodIncomingPhoneNumberMobile, Error<CreateIncomingPhoneNumberMobileError>> {
2044    let local_var_configuration = configuration;
2045
2046    let local_var_client = &local_var_configuration.client;
2047
2048    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/Mobile.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
2049    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2050
2051    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2052        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2053    }
2054    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2055        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2056    };
2057    let mut local_var_form_params = std::collections::HashMap::new();
2058    local_var_form_params.insert("PhoneNumber", phone_number.to_string());
2059    if let Some(local_var_param_value) = api_version {
2060        local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
2061    }
2062    if let Some(local_var_param_value) = friendly_name {
2063        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
2064    }
2065    if let Some(local_var_param_value) = sms_application_sid {
2066        local_var_form_params.insert("SmsApplicationSid", local_var_param_value.to_string());
2067    }
2068    if let Some(local_var_param_value) = sms_fallback_method {
2069        local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
2070    }
2071    if let Some(local_var_param_value) = sms_fallback_url {
2072        local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
2073    }
2074    if let Some(local_var_param_value) = sms_method {
2075        local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
2076    }
2077    if let Some(local_var_param_value) = sms_url {
2078        local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
2079    }
2080    if let Some(local_var_param_value) = status_callback {
2081        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
2082    }
2083    if let Some(local_var_param_value) = status_callback_method {
2084        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
2085    }
2086    if let Some(local_var_param_value) = voice_application_sid {
2087        local_var_form_params.insert("VoiceApplicationSid", local_var_param_value.to_string());
2088    }
2089    if let Some(local_var_param_value) = voice_caller_id_lookup {
2090        local_var_form_params.insert("VoiceCallerIdLookup", local_var_param_value.to_string());
2091    }
2092    if let Some(local_var_param_value) = voice_fallback_method {
2093        local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
2094    }
2095    if let Some(local_var_param_value) = voice_fallback_url {
2096        local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
2097    }
2098    if let Some(local_var_param_value) = voice_method {
2099        local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
2100    }
2101    if let Some(local_var_param_value) = voice_url {
2102        local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
2103    }
2104    if let Some(local_var_param_value) = identity_sid {
2105        local_var_form_params.insert("IdentitySid", local_var_param_value.to_string());
2106    }
2107    if let Some(local_var_param_value) = address_sid {
2108        local_var_form_params.insert("AddressSid", local_var_param_value.to_string());
2109    }
2110    if let Some(local_var_param_value) = emergency_status {
2111        local_var_form_params.insert("EmergencyStatus", local_var_param_value.to_string());
2112    }
2113    if let Some(local_var_param_value) = emergency_address_sid {
2114        local_var_form_params.insert("EmergencyAddressSid", local_var_param_value.to_string());
2115    }
2116    if let Some(local_var_param_value) = trunk_sid {
2117        local_var_form_params.insert("TrunkSid", local_var_param_value.to_string());
2118    }
2119    if let Some(local_var_param_value) = voice_receive_mode {
2120        local_var_form_params.insert("VoiceReceiveMode", local_var_param_value.to_string());
2121    }
2122    if let Some(local_var_param_value) = bundle_sid {
2123        local_var_form_params.insert("BundleSid", local_var_param_value.to_string());
2124    }
2125    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2126
2127    let local_var_req = local_var_req_builder.build()?;
2128    let local_var_resp = local_var_client.execute(local_var_req).await?;
2129
2130    let local_var_status = local_var_resp.status();
2131    let local_var_content = local_var_resp.text().await?;
2132
2133    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2134        serde_json::from_str(&local_var_content).map_err(Error::from)
2135    } else {
2136        let local_var_entity: Option<CreateIncomingPhoneNumberMobileError> = serde_json::from_str(&local_var_content).ok();
2137        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2138        Err(Error::ResponseError(local_var_error))
2139    }
2140}
2141
2142/// 
2143pub async fn create_incoming_phone_number_toll_free(configuration: &configuration::Configuration, account_sid: &str, phone_number: &str, api_version: Option<&str>, friendly_name: Option<&str>, sms_application_sid: Option<&str>, sms_fallback_method: Option<&str>, sms_fallback_url: Option<&str>, sms_method: Option<&str>, sms_url: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, voice_application_sid: Option<&str>, voice_caller_id_lookup: Option<bool>, voice_fallback_method: Option<&str>, voice_fallback_url: Option<&str>, voice_method: Option<&str>, voice_url: Option<&str>, identity_sid: Option<&str>, address_sid: Option<&str>, emergency_status: Option<&str>, emergency_address_sid: Option<&str>, trunk_sid: Option<&str>, voice_receive_mode: Option<&str>, bundle_sid: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodIncomingPhoneNumberPeriodIncomingPhoneNumberTollFree, Error<CreateIncomingPhoneNumberTollFreeError>> {
2144    let local_var_configuration = configuration;
2145
2146    let local_var_client = &local_var_configuration.client;
2147
2148    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/TollFree.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
2149    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2150
2151    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2152        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2153    }
2154    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2155        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2156    };
2157    let mut local_var_form_params = std::collections::HashMap::new();
2158    local_var_form_params.insert("PhoneNumber", phone_number.to_string());
2159    if let Some(local_var_param_value) = api_version {
2160        local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
2161    }
2162    if let Some(local_var_param_value) = friendly_name {
2163        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
2164    }
2165    if let Some(local_var_param_value) = sms_application_sid {
2166        local_var_form_params.insert("SmsApplicationSid", local_var_param_value.to_string());
2167    }
2168    if let Some(local_var_param_value) = sms_fallback_method {
2169        local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
2170    }
2171    if let Some(local_var_param_value) = sms_fallback_url {
2172        local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
2173    }
2174    if let Some(local_var_param_value) = sms_method {
2175        local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
2176    }
2177    if let Some(local_var_param_value) = sms_url {
2178        local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
2179    }
2180    if let Some(local_var_param_value) = status_callback {
2181        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
2182    }
2183    if let Some(local_var_param_value) = status_callback_method {
2184        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
2185    }
2186    if let Some(local_var_param_value) = voice_application_sid {
2187        local_var_form_params.insert("VoiceApplicationSid", local_var_param_value.to_string());
2188    }
2189    if let Some(local_var_param_value) = voice_caller_id_lookup {
2190        local_var_form_params.insert("VoiceCallerIdLookup", local_var_param_value.to_string());
2191    }
2192    if let Some(local_var_param_value) = voice_fallback_method {
2193        local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
2194    }
2195    if let Some(local_var_param_value) = voice_fallback_url {
2196        local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
2197    }
2198    if let Some(local_var_param_value) = voice_method {
2199        local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
2200    }
2201    if let Some(local_var_param_value) = voice_url {
2202        local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
2203    }
2204    if let Some(local_var_param_value) = identity_sid {
2205        local_var_form_params.insert("IdentitySid", local_var_param_value.to_string());
2206    }
2207    if let Some(local_var_param_value) = address_sid {
2208        local_var_form_params.insert("AddressSid", local_var_param_value.to_string());
2209    }
2210    if let Some(local_var_param_value) = emergency_status {
2211        local_var_form_params.insert("EmergencyStatus", local_var_param_value.to_string());
2212    }
2213    if let Some(local_var_param_value) = emergency_address_sid {
2214        local_var_form_params.insert("EmergencyAddressSid", local_var_param_value.to_string());
2215    }
2216    if let Some(local_var_param_value) = trunk_sid {
2217        local_var_form_params.insert("TrunkSid", local_var_param_value.to_string());
2218    }
2219    if let Some(local_var_param_value) = voice_receive_mode {
2220        local_var_form_params.insert("VoiceReceiveMode", local_var_param_value.to_string());
2221    }
2222    if let Some(local_var_param_value) = bundle_sid {
2223        local_var_form_params.insert("BundleSid", local_var_param_value.to_string());
2224    }
2225    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2226
2227    let local_var_req = local_var_req_builder.build()?;
2228    let local_var_resp = local_var_client.execute(local_var_req).await?;
2229
2230    let local_var_status = local_var_resp.status();
2231    let local_var_content = local_var_resp.text().await?;
2232
2233    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2234        serde_json::from_str(&local_var_content).map_err(Error::from)
2235    } else {
2236        let local_var_entity: Option<CreateIncomingPhoneNumberTollFreeError> = serde_json::from_str(&local_var_content).ok();
2237        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2238        Err(Error::ResponseError(local_var_error))
2239    }
2240}
2241
2242/// Send a message from the account used to make the request
2243pub async fn create_message(configuration: &configuration::Configuration, account_sid: &str, to: &str, status_callback: Option<&str>, application_sid: Option<&str>, max_price: Option<f32>, provide_feedback: Option<bool>, attempt: Option<i32>, validity_period: Option<i32>, force_delivery: Option<bool>, content_retention: Option<&str>, address_retention: Option<&str>, smart_encoded: Option<bool>, persistent_action: Option<Vec<String>>, shorten_urls: Option<bool>, schedule_type: Option<&str>, send_at: Option<String>, send_as_mms: Option<bool>, content_sid: Option<&str>, content_variables: Option<&str>, from: Option<&str>, messaging_service_sid: Option<&str>, body: Option<&str>, media_url: Option<Vec<String>>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodMessage, Error<CreateMessageError>> {
2244    let local_var_configuration = configuration;
2245
2246    let local_var_client = &local_var_configuration.client;
2247
2248    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
2249    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2250
2251    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2252        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2253    }
2254    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2255        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2256    };
2257    let mut local_var_form_params = std::collections::HashMap::new();
2258    local_var_form_params.insert("To", to.to_string());
2259    if let Some(local_var_param_value) = status_callback {
2260        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
2261    }
2262    if let Some(local_var_param_value) = application_sid {
2263        local_var_form_params.insert("ApplicationSid", local_var_param_value.to_string());
2264    }
2265    if let Some(local_var_param_value) = max_price {
2266        local_var_form_params.insert("MaxPrice", local_var_param_value.to_string());
2267    }
2268    if let Some(local_var_param_value) = provide_feedback {
2269        local_var_form_params.insert("ProvideFeedback", local_var_param_value.to_string());
2270    }
2271    if let Some(local_var_param_value) = attempt {
2272        local_var_form_params.insert("Attempt", local_var_param_value.to_string());
2273    }
2274    if let Some(local_var_param_value) = validity_period {
2275        local_var_form_params.insert("ValidityPeriod", local_var_param_value.to_string());
2276    }
2277    if let Some(local_var_param_value) = force_delivery {
2278        local_var_form_params.insert("ForceDelivery", local_var_param_value.to_string());
2279    }
2280    if let Some(local_var_param_value) = content_retention {
2281        local_var_form_params.insert("ContentRetention", local_var_param_value.to_string());
2282    }
2283    if let Some(local_var_param_value) = address_retention {
2284        local_var_form_params.insert("AddressRetention", local_var_param_value.to_string());
2285    }
2286    if let Some(local_var_param_value) = smart_encoded {
2287        local_var_form_params.insert("SmartEncoded", local_var_param_value.to_string());
2288    }
2289    if let Some(local_var_param_value) = persistent_action {
2290        local_var_form_params.insert("PersistentAction", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
2291    }
2292    if let Some(local_var_param_value) = shorten_urls {
2293        local_var_form_params.insert("ShortenUrls", local_var_param_value.to_string());
2294    }
2295    if let Some(local_var_param_value) = schedule_type {
2296        local_var_form_params.insert("ScheduleType", local_var_param_value.to_string());
2297    }
2298    if let Some(local_var_param_value) = send_at {
2299        local_var_form_params.insert("SendAt", local_var_param_value.to_string());
2300    }
2301    if let Some(local_var_param_value) = send_as_mms {
2302        local_var_form_params.insert("SendAsMms", local_var_param_value.to_string());
2303    }
2304    if let Some(local_var_param_value) = content_sid {
2305        local_var_form_params.insert("ContentSid", local_var_param_value.to_string());
2306    }
2307    if let Some(local_var_param_value) = content_variables {
2308        local_var_form_params.insert("ContentVariables", local_var_param_value.to_string());
2309    }
2310    if let Some(local_var_param_value) = from {
2311        local_var_form_params.insert("From", local_var_param_value.to_string());
2312    }
2313    if let Some(local_var_param_value) = messaging_service_sid {
2314        local_var_form_params.insert("MessagingServiceSid", local_var_param_value.to_string());
2315    }
2316    if let Some(local_var_param_value) = body {
2317        local_var_form_params.insert("Body", local_var_param_value.to_string());
2318    }
2319    if let Some(local_var_param_value) = media_url {
2320        local_var_form_params.insert("MediaUrl", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
2321    }
2322    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2323
2324    let local_var_req = local_var_req_builder.build()?;
2325    let local_var_resp = local_var_client.execute(local_var_req).await?;
2326
2327    let local_var_status = local_var_resp.status();
2328    let local_var_content = local_var_resp.text().await?;
2329
2330    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2331        serde_json::from_str(&local_var_content).map_err(Error::from)
2332    } else {
2333        let local_var_entity: Option<CreateMessageError> = serde_json::from_str(&local_var_content).ok();
2334        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2335        Err(Error::ResponseError(local_var_error))
2336    }
2337}
2338
2339/// 
2340pub async fn create_message_feedback(configuration: &configuration::Configuration, account_sid: &str, message_sid: &str, outcome: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodMessagePeriodMessageFeedback, Error<CreateMessageFeedbackError>> {
2341    let local_var_configuration = configuration;
2342
2343    let local_var_client = &local_var_configuration.client;
2344
2345    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{MessageSid}/Feedback.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), MessageSid=crate::apis::urlencode(message_sid));
2346    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2347
2348    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2349        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2350    }
2351    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2352        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2353    };
2354    let mut local_var_form_params = std::collections::HashMap::new();
2355    if let Some(local_var_param_value) = outcome {
2356        local_var_form_params.insert("Outcome", local_var_param_value.to_string());
2357    }
2358    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2359
2360    let local_var_req = local_var_req_builder.build()?;
2361    let local_var_resp = local_var_client.execute(local_var_req).await?;
2362
2363    let local_var_status = local_var_resp.status();
2364    let local_var_content = local_var_resp.text().await?;
2365
2366    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2367        serde_json::from_str(&local_var_content).map_err(Error::from)
2368    } else {
2369        let local_var_entity: Option<CreateMessageFeedbackError> = serde_json::from_str(&local_var_content).ok();
2370        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2371        Err(Error::ResponseError(local_var_error))
2372    }
2373}
2374
2375/// 
2376pub async fn create_new_key(configuration: &configuration::Configuration, account_sid: &str, friendly_name: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodNewKey, Error<CreateNewKeyError>> {
2377    let local_var_configuration = configuration;
2378
2379    let local_var_client = &local_var_configuration.client;
2380
2381    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Keys.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
2382    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2383
2384    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2385        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2386    }
2387    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2388        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2389    };
2390    let mut local_var_form_params = std::collections::HashMap::new();
2391    if let Some(local_var_param_value) = friendly_name {
2392        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
2393    }
2394    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2395
2396    let local_var_req = local_var_req_builder.build()?;
2397    let local_var_resp = local_var_client.execute(local_var_req).await?;
2398
2399    let local_var_status = local_var_resp.status();
2400    let local_var_content = local_var_resp.text().await?;
2401
2402    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2403        serde_json::from_str(&local_var_content).map_err(Error::from)
2404    } else {
2405        let local_var_entity: Option<CreateNewKeyError> = serde_json::from_str(&local_var_content).ok();
2406        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2407        Err(Error::ResponseError(local_var_error))
2408    }
2409}
2410
2411/// Create a new Signing Key for the account making the request.
2412pub async fn create_new_signing_key(configuration: &configuration::Configuration, account_sid: &str, friendly_name: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodNewSigningKey, Error<CreateNewSigningKeyError>> {
2413    let local_var_configuration = configuration;
2414
2415    let local_var_client = &local_var_configuration.client;
2416
2417    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SigningKeys.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
2418    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2419
2420    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2421        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2422    }
2423    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2424        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2425    };
2426    let mut local_var_form_params = std::collections::HashMap::new();
2427    if let Some(local_var_param_value) = friendly_name {
2428        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
2429    }
2430    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2431
2432    let local_var_req = local_var_req_builder.build()?;
2433    let local_var_resp = local_var_client.execute(local_var_req).await?;
2434
2435    let local_var_status = local_var_resp.status();
2436    let local_var_content = local_var_resp.text().await?;
2437
2438    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2439        serde_json::from_str(&local_var_content).map_err(Error::from)
2440    } else {
2441        let local_var_entity: Option<CreateNewSigningKeyError> = serde_json::from_str(&local_var_content).ok();
2442        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2443        Err(Error::ResponseError(local_var_error))
2444    }
2445}
2446
2447/// 
2448pub async fn create_participant(configuration: &configuration::Configuration, account_sid: &str, conference_sid: &str, from: &str, to: &str, status_callback: Option<&str>, status_callback_method: Option<&str>, status_callback_event: Option<Vec<String>>, label: Option<&str>, timeout: Option<i32>, record: Option<bool>, muted: Option<bool>, beep: Option<&str>, start_conference_on_enter: Option<bool>, end_conference_on_exit: Option<bool>, wait_url: Option<&str>, wait_method: Option<&str>, early_media: Option<bool>, max_participants: Option<i32>, conference_record: Option<&str>, conference_trim: Option<&str>, conference_status_callback: Option<&str>, conference_status_callback_method: Option<&str>, conference_status_callback_event: Option<Vec<String>>, recording_channels: Option<&str>, recording_status_callback: Option<&str>, recording_status_callback_method: Option<&str>, sip_auth_username: Option<&str>, sip_auth_password: Option<&str>, region: Option<&str>, conference_recording_status_callback: Option<&str>, conference_recording_status_callback_method: Option<&str>, recording_status_callback_event: Option<Vec<String>>, conference_recording_status_callback_event: Option<Vec<String>>, coaching: Option<bool>, call_sid_to_coach: Option<&str>, jitter_buffer_size: Option<&str>, byoc: Option<&str>, caller_id: Option<&str>, call_reason: Option<&str>, recording_track: Option<&str>, time_limit: Option<i32>, machine_detection: Option<&str>, machine_detection_timeout: Option<i32>, machine_detection_speech_threshold: Option<i32>, machine_detection_speech_end_threshold: Option<i32>, machine_detection_silence_timeout: Option<i32>, amd_status_callback: Option<&str>, amd_status_callback_method: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodConferencePeriodParticipant, Error<CreateParticipantError>> {
2449    let local_var_configuration = configuration;
2450
2451    let local_var_client = &local_var_configuration.client;
2452
2453    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{ConferenceSid}/Participants.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConferenceSid=crate::apis::urlencode(conference_sid));
2454    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2455
2456    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2457        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2458    }
2459    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2460        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2461    };
2462    let mut local_var_form_params = std::collections::HashMap::new();
2463    local_var_form_params.insert("From", from.to_string());
2464    local_var_form_params.insert("To", to.to_string());
2465    if let Some(local_var_param_value) = status_callback {
2466        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
2467    }
2468    if let Some(local_var_param_value) = status_callback_method {
2469        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
2470    }
2471    if let Some(local_var_param_value) = status_callback_event {
2472        local_var_form_params.insert("StatusCallbackEvent", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
2473    }
2474    if let Some(local_var_param_value) = label {
2475        local_var_form_params.insert("Label", local_var_param_value.to_string());
2476    }
2477    if let Some(local_var_param_value) = timeout {
2478        local_var_form_params.insert("Timeout", local_var_param_value.to_string());
2479    }
2480    if let Some(local_var_param_value) = record {
2481        local_var_form_params.insert("Record", local_var_param_value.to_string());
2482    }
2483    if let Some(local_var_param_value) = muted {
2484        local_var_form_params.insert("Muted", local_var_param_value.to_string());
2485    }
2486    if let Some(local_var_param_value) = beep {
2487        local_var_form_params.insert("Beep", local_var_param_value.to_string());
2488    }
2489    if let Some(local_var_param_value) = start_conference_on_enter {
2490        local_var_form_params.insert("StartConferenceOnEnter", local_var_param_value.to_string());
2491    }
2492    if let Some(local_var_param_value) = end_conference_on_exit {
2493        local_var_form_params.insert("EndConferenceOnExit", local_var_param_value.to_string());
2494    }
2495    if let Some(local_var_param_value) = wait_url {
2496        local_var_form_params.insert("WaitUrl", local_var_param_value.to_string());
2497    }
2498    if let Some(local_var_param_value) = wait_method {
2499        local_var_form_params.insert("WaitMethod", local_var_param_value.to_string());
2500    }
2501    if let Some(local_var_param_value) = early_media {
2502        local_var_form_params.insert("EarlyMedia", local_var_param_value.to_string());
2503    }
2504    if let Some(local_var_param_value) = max_participants {
2505        local_var_form_params.insert("MaxParticipants", local_var_param_value.to_string());
2506    }
2507    if let Some(local_var_param_value) = conference_record {
2508        local_var_form_params.insert("ConferenceRecord", local_var_param_value.to_string());
2509    }
2510    if let Some(local_var_param_value) = conference_trim {
2511        local_var_form_params.insert("ConferenceTrim", local_var_param_value.to_string());
2512    }
2513    if let Some(local_var_param_value) = conference_status_callback {
2514        local_var_form_params.insert("ConferenceStatusCallback", local_var_param_value.to_string());
2515    }
2516    if let Some(local_var_param_value) = conference_status_callback_method {
2517        local_var_form_params.insert("ConferenceStatusCallbackMethod", local_var_param_value.to_string());
2518    }
2519    if let Some(local_var_param_value) = conference_status_callback_event {
2520        local_var_form_params.insert("ConferenceStatusCallbackEvent", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
2521    }
2522    if let Some(local_var_param_value) = recording_channels {
2523        local_var_form_params.insert("RecordingChannels", local_var_param_value.to_string());
2524    }
2525    if let Some(local_var_param_value) = recording_status_callback {
2526        local_var_form_params.insert("RecordingStatusCallback", local_var_param_value.to_string());
2527    }
2528    if let Some(local_var_param_value) = recording_status_callback_method {
2529        local_var_form_params.insert("RecordingStatusCallbackMethod", local_var_param_value.to_string());
2530    }
2531    if let Some(local_var_param_value) = sip_auth_username {
2532        local_var_form_params.insert("SipAuthUsername", local_var_param_value.to_string());
2533    }
2534    if let Some(local_var_param_value) = sip_auth_password {
2535        local_var_form_params.insert("SipAuthPassword", local_var_param_value.to_string());
2536    }
2537    if let Some(local_var_param_value) = region {
2538        local_var_form_params.insert("Region", local_var_param_value.to_string());
2539    }
2540    if let Some(local_var_param_value) = conference_recording_status_callback {
2541        local_var_form_params.insert("ConferenceRecordingStatusCallback", local_var_param_value.to_string());
2542    }
2543    if let Some(local_var_param_value) = conference_recording_status_callback_method {
2544        local_var_form_params.insert("ConferenceRecordingStatusCallbackMethod", local_var_param_value.to_string());
2545    }
2546    if let Some(local_var_param_value) = recording_status_callback_event {
2547        local_var_form_params.insert("RecordingStatusCallbackEvent", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
2548    }
2549    if let Some(local_var_param_value) = conference_recording_status_callback_event {
2550        local_var_form_params.insert("ConferenceRecordingStatusCallbackEvent", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
2551    }
2552    if let Some(local_var_param_value) = coaching {
2553        local_var_form_params.insert("Coaching", local_var_param_value.to_string());
2554    }
2555    if let Some(local_var_param_value) = call_sid_to_coach {
2556        local_var_form_params.insert("CallSidToCoach", local_var_param_value.to_string());
2557    }
2558    if let Some(local_var_param_value) = jitter_buffer_size {
2559        local_var_form_params.insert("JitterBufferSize", local_var_param_value.to_string());
2560    }
2561    if let Some(local_var_param_value) = byoc {
2562        local_var_form_params.insert("Byoc", local_var_param_value.to_string());
2563    }
2564    if let Some(local_var_param_value) = caller_id {
2565        local_var_form_params.insert("CallerId", local_var_param_value.to_string());
2566    }
2567    if let Some(local_var_param_value) = call_reason {
2568        local_var_form_params.insert("CallReason", local_var_param_value.to_string());
2569    }
2570    if let Some(local_var_param_value) = recording_track {
2571        local_var_form_params.insert("RecordingTrack", local_var_param_value.to_string());
2572    }
2573    if let Some(local_var_param_value) = time_limit {
2574        local_var_form_params.insert("TimeLimit", local_var_param_value.to_string());
2575    }
2576    if let Some(local_var_param_value) = machine_detection {
2577        local_var_form_params.insert("MachineDetection", local_var_param_value.to_string());
2578    }
2579    if let Some(local_var_param_value) = machine_detection_timeout {
2580        local_var_form_params.insert("MachineDetectionTimeout", local_var_param_value.to_string());
2581    }
2582    if let Some(local_var_param_value) = machine_detection_speech_threshold {
2583        local_var_form_params.insert("MachineDetectionSpeechThreshold", local_var_param_value.to_string());
2584    }
2585    if let Some(local_var_param_value) = machine_detection_speech_end_threshold {
2586        local_var_form_params.insert("MachineDetectionSpeechEndThreshold", local_var_param_value.to_string());
2587    }
2588    if let Some(local_var_param_value) = machine_detection_silence_timeout {
2589        local_var_form_params.insert("MachineDetectionSilenceTimeout", local_var_param_value.to_string());
2590    }
2591    if let Some(local_var_param_value) = amd_status_callback {
2592        local_var_form_params.insert("AmdStatusCallback", local_var_param_value.to_string());
2593    }
2594    if let Some(local_var_param_value) = amd_status_callback_method {
2595        local_var_form_params.insert("AmdStatusCallbackMethod", local_var_param_value.to_string());
2596    }
2597    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2598
2599    let local_var_req = local_var_req_builder.build()?;
2600    let local_var_resp = local_var_client.execute(local_var_req).await?;
2601
2602    let local_var_status = local_var_resp.status();
2603    let local_var_content = local_var_resp.text().await?;
2604
2605    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2606        serde_json::from_str(&local_var_content).map_err(Error::from)
2607    } else {
2608        let local_var_entity: Option<CreateParticipantError> = serde_json::from_str(&local_var_content).ok();
2609        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2610        Err(Error::ResponseError(local_var_error))
2611    }
2612}
2613
2614/// create an instance of payments. This will start a new payments session
2615pub async fn create_payments(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, idempotency_key: &str, status_callback: &str, bank_account_type: Option<&str>, charge_amount: Option<f32>, currency: Option<&str>, description: Option<&str>, input: Option<&str>, min_postal_code_length: Option<i32>, parameter: Option<serde_json::Value>, payment_connector: Option<&str>, payment_method: Option<&str>, postal_code: Option<bool>, security_code: Option<bool>, timeout: Option<i32>, token_type: Option<&str>, valid_card_types: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodPayments, Error<CreatePaymentsError>> {
2616    let local_var_configuration = configuration;
2617
2618    let local_var_client = &local_var_configuration.client;
2619
2620    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Payments.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
2621    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2622
2623    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2624        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2625    }
2626    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2627        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2628    };
2629    let mut local_var_form_params = std::collections::HashMap::new();
2630    local_var_form_params.insert("IdempotencyKey", idempotency_key.to_string());
2631    local_var_form_params.insert("StatusCallback", status_callback.to_string());
2632    if let Some(local_var_param_value) = bank_account_type {
2633        local_var_form_params.insert("BankAccountType", local_var_param_value.to_string());
2634    }
2635    if let Some(local_var_param_value) = charge_amount {
2636        local_var_form_params.insert("ChargeAmount", local_var_param_value.to_string());
2637    }
2638    if let Some(local_var_param_value) = currency {
2639        local_var_form_params.insert("Currency", local_var_param_value.to_string());
2640    }
2641    if let Some(local_var_param_value) = description {
2642        local_var_form_params.insert("Description", local_var_param_value.to_string());
2643    }
2644    if let Some(local_var_param_value) = input {
2645        local_var_form_params.insert("Input", local_var_param_value.to_string());
2646    }
2647    if let Some(local_var_param_value) = min_postal_code_length {
2648        local_var_form_params.insert("MinPostalCodeLength", local_var_param_value.to_string());
2649    }
2650    if let Some(local_var_param_value) = parameter {
2651        local_var_form_params.insert("Parameter", local_var_param_value.to_string());
2652    }
2653    if let Some(local_var_param_value) = payment_connector {
2654        local_var_form_params.insert("PaymentConnector", local_var_param_value.to_string());
2655    }
2656    if let Some(local_var_param_value) = payment_method {
2657        local_var_form_params.insert("PaymentMethod", local_var_param_value.to_string());
2658    }
2659    if let Some(local_var_param_value) = postal_code {
2660        local_var_form_params.insert("PostalCode", local_var_param_value.to_string());
2661    }
2662    if let Some(local_var_param_value) = security_code {
2663        local_var_form_params.insert("SecurityCode", local_var_param_value.to_string());
2664    }
2665    if let Some(local_var_param_value) = timeout {
2666        local_var_form_params.insert("Timeout", local_var_param_value.to_string());
2667    }
2668    if let Some(local_var_param_value) = token_type {
2669        local_var_form_params.insert("TokenType", local_var_param_value.to_string());
2670    }
2671    if let Some(local_var_param_value) = valid_card_types {
2672        local_var_form_params.insert("ValidCardTypes", local_var_param_value.to_string());
2673    }
2674    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2675
2676    let local_var_req = local_var_req_builder.build()?;
2677    let local_var_resp = local_var_client.execute(local_var_req).await?;
2678
2679    let local_var_status = local_var_resp.status();
2680    let local_var_content = local_var_resp.text().await?;
2681
2682    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2683        serde_json::from_str(&local_var_content).map_err(Error::from)
2684    } else {
2685        let local_var_entity: Option<CreatePaymentsError> = serde_json::from_str(&local_var_content).ok();
2686        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2687        Err(Error::ResponseError(local_var_error))
2688    }
2689}
2690
2691/// Create a queue
2692pub async fn create_queue(configuration: &configuration::Configuration, account_sid: &str, friendly_name: &str, max_size: Option<i32>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodQueue, Error<CreateQueueError>> {
2693    let local_var_configuration = configuration;
2694
2695    let local_var_client = &local_var_configuration.client;
2696
2697    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Queues.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
2698    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2699
2700    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2701        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2702    }
2703    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2704        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2705    };
2706    let mut local_var_form_params = std::collections::HashMap::new();
2707    local_var_form_params.insert("FriendlyName", friendly_name.to_string());
2708    if let Some(local_var_param_value) = max_size {
2709        local_var_form_params.insert("MaxSize", local_var_param_value.to_string());
2710    }
2711    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2712
2713    let local_var_req = local_var_req_builder.build()?;
2714    let local_var_resp = local_var_client.execute(local_var_req).await?;
2715
2716    let local_var_status = local_var_resp.status();
2717    let local_var_content = local_var_resp.text().await?;
2718
2719    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2720        serde_json::from_str(&local_var_content).map_err(Error::from)
2721    } else {
2722        let local_var_entity: Option<CreateQueueError> = serde_json::from_str(&local_var_content).ok();
2723        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2724        Err(Error::ResponseError(local_var_error))
2725    }
2726}
2727
2728/// Create a new credential list mapping resource
2729pub async fn create_sip_auth_calls_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, credential_list_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipAuthPeriodSipAuthCallsPeriodSipAuthCallsCredentialListMapping, Error<CreateSipAuthCallsCredentialListMappingError>> {
2730    let local_var_configuration = configuration;
2731
2732    let local_var_client = &local_var_configuration.client;
2733
2734    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/CredentialListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
2735    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2736
2737    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2738        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2739    }
2740    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2741        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2742    };
2743    let mut local_var_form_params = std::collections::HashMap::new();
2744    local_var_form_params.insert("CredentialListSid", credential_list_sid.to_string());
2745    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2746
2747    let local_var_req = local_var_req_builder.build()?;
2748    let local_var_resp = local_var_client.execute(local_var_req).await?;
2749
2750    let local_var_status = local_var_resp.status();
2751    let local_var_content = local_var_resp.text().await?;
2752
2753    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2754        serde_json::from_str(&local_var_content).map_err(Error::from)
2755    } else {
2756        let local_var_entity: Option<CreateSipAuthCallsCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
2757        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2758        Err(Error::ResponseError(local_var_error))
2759    }
2760}
2761
2762/// Create a new IP Access Control List mapping
2763pub async fn create_sip_auth_calls_ip_access_control_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, ip_access_control_list_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipAuthPeriodSipAuthCallsPeriodSipAuthCallsIpAccessControlListMapping, Error<CreateSipAuthCallsIpAccessControlListMappingError>> {
2764    let local_var_configuration = configuration;
2765
2766    let local_var_client = &local_var_configuration.client;
2767
2768    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/IpAccessControlListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
2769    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2770
2771    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2772        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2773    }
2774    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2775        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2776    };
2777    let mut local_var_form_params = std::collections::HashMap::new();
2778    local_var_form_params.insert("IpAccessControlListSid", ip_access_control_list_sid.to_string());
2779    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2780
2781    let local_var_req = local_var_req_builder.build()?;
2782    let local_var_resp = local_var_client.execute(local_var_req).await?;
2783
2784    let local_var_status = local_var_resp.status();
2785    let local_var_content = local_var_resp.text().await?;
2786
2787    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2788        serde_json::from_str(&local_var_content).map_err(Error::from)
2789    } else {
2790        let local_var_entity: Option<CreateSipAuthCallsIpAccessControlListMappingError> = serde_json::from_str(&local_var_content).ok();
2791        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2792        Err(Error::ResponseError(local_var_error))
2793    }
2794}
2795
2796/// Create a new credential list mapping resource
2797pub async fn create_sip_auth_registrations_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, credential_list_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipAuthPeriodSipAuthRegistrationsPeriodSipAuthRegistrationsCredentialListMapping, Error<CreateSipAuthRegistrationsCredentialListMappingError>> {
2798    let local_var_configuration = configuration;
2799
2800    let local_var_client = &local_var_configuration.client;
2801
2802    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Registrations/CredentialListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
2803    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2804
2805    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2806        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2807    }
2808    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2809        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2810    };
2811    let mut local_var_form_params = std::collections::HashMap::new();
2812    local_var_form_params.insert("CredentialListSid", credential_list_sid.to_string());
2813    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2814
2815    let local_var_req = local_var_req_builder.build()?;
2816    let local_var_resp = local_var_client.execute(local_var_req).await?;
2817
2818    let local_var_status = local_var_resp.status();
2819    let local_var_content = local_var_resp.text().await?;
2820
2821    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2822        serde_json::from_str(&local_var_content).map_err(Error::from)
2823    } else {
2824        let local_var_entity: Option<CreateSipAuthRegistrationsCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
2825        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2826        Err(Error::ResponseError(local_var_error))
2827    }
2828}
2829
2830/// Create a new credential resource.
2831pub async fn create_sip_credential(configuration: &configuration::Configuration, account_sid: &str, credential_list_sid: &str, username: &str, password: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipCredentialListPeriodSipCredential, Error<CreateSipCredentialError>> {
2832    let local_var_configuration = configuration;
2833
2834    let local_var_client = &local_var_configuration.client;
2835
2836    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists/{CredentialListSid}/Credentials.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CredentialListSid=crate::apis::urlencode(credential_list_sid));
2837    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2838
2839    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2840        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2841    }
2842    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2843        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2844    };
2845    let mut local_var_form_params = std::collections::HashMap::new();
2846    local_var_form_params.insert("Username", username.to_string());
2847    local_var_form_params.insert("Password", password.to_string());
2848    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2849
2850    let local_var_req = local_var_req_builder.build()?;
2851    let local_var_resp = local_var_client.execute(local_var_req).await?;
2852
2853    let local_var_status = local_var_resp.status();
2854    let local_var_content = local_var_resp.text().await?;
2855
2856    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2857        serde_json::from_str(&local_var_content).map_err(Error::from)
2858    } else {
2859        let local_var_entity: Option<CreateSipCredentialError> = serde_json::from_str(&local_var_content).ok();
2860        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2861        Err(Error::ResponseError(local_var_error))
2862    }
2863}
2864
2865/// Create a Credential List
2866pub async fn create_sip_credential_list(configuration: &configuration::Configuration, account_sid: &str, friendly_name: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipCredentialList, Error<CreateSipCredentialListError>> {
2867    let local_var_configuration = configuration;
2868
2869    let local_var_client = &local_var_configuration.client;
2870
2871    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
2872    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2873
2874    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2875        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2876    }
2877    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2878        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2879    };
2880    let mut local_var_form_params = std::collections::HashMap::new();
2881    local_var_form_params.insert("FriendlyName", friendly_name.to_string());
2882    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2883
2884    let local_var_req = local_var_req_builder.build()?;
2885    let local_var_resp = local_var_client.execute(local_var_req).await?;
2886
2887    let local_var_status = local_var_resp.status();
2888    let local_var_content = local_var_resp.text().await?;
2889
2890    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2891        serde_json::from_str(&local_var_content).map_err(Error::from)
2892    } else {
2893        let local_var_entity: Option<CreateSipCredentialListError> = serde_json::from_str(&local_var_content).ok();
2894        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2895        Err(Error::ResponseError(local_var_error))
2896    }
2897}
2898
2899/// Create a CredentialListMapping resource for an account.
2900pub async fn create_sip_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, credential_list_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipCredentialListMapping, Error<CreateSipCredentialListMappingError>> {
2901    let local_var_configuration = configuration;
2902
2903    let local_var_client = &local_var_configuration.client;
2904
2905    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/CredentialListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
2906    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2907
2908    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2909        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2910    }
2911    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2912        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2913    };
2914    let mut local_var_form_params = std::collections::HashMap::new();
2915    local_var_form_params.insert("CredentialListSid", credential_list_sid.to_string());
2916    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2917
2918    let local_var_req = local_var_req_builder.build()?;
2919    let local_var_resp = local_var_client.execute(local_var_req).await?;
2920
2921    let local_var_status = local_var_resp.status();
2922    let local_var_content = local_var_resp.text().await?;
2923
2924    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2925        serde_json::from_str(&local_var_content).map_err(Error::from)
2926    } else {
2927        let local_var_entity: Option<CreateSipCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
2928        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2929        Err(Error::ResponseError(local_var_error))
2930    }
2931}
2932
2933/// Create a new Domain
2934pub async fn create_sip_domain(configuration: &configuration::Configuration, account_sid: &str, domain_name: &str, friendly_name: Option<&str>, voice_url: Option<&str>, voice_method: Option<&str>, voice_fallback_url: Option<&str>, voice_fallback_method: Option<&str>, voice_status_callback_url: Option<&str>, voice_status_callback_method: Option<&str>, sip_registration: Option<bool>, emergency_calling_enabled: Option<bool>, secure: Option<bool>, byoc_trunk_sid: Option<&str>, emergency_caller_sid: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomain, Error<CreateSipDomainError>> {
2935    let local_var_configuration = configuration;
2936
2937    let local_var_client = &local_var_configuration.client;
2938
2939    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
2940    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
2941
2942    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
2943        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
2944    }
2945    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
2946        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
2947    };
2948    let mut local_var_form_params = std::collections::HashMap::new();
2949    local_var_form_params.insert("DomainName", domain_name.to_string());
2950    if let Some(local_var_param_value) = friendly_name {
2951        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
2952    }
2953    if let Some(local_var_param_value) = voice_url {
2954        local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
2955    }
2956    if let Some(local_var_param_value) = voice_method {
2957        local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
2958    }
2959    if let Some(local_var_param_value) = voice_fallback_url {
2960        local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
2961    }
2962    if let Some(local_var_param_value) = voice_fallback_method {
2963        local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
2964    }
2965    if let Some(local_var_param_value) = voice_status_callback_url {
2966        local_var_form_params.insert("VoiceStatusCallbackUrl", local_var_param_value.to_string());
2967    }
2968    if let Some(local_var_param_value) = voice_status_callback_method {
2969        local_var_form_params.insert("VoiceStatusCallbackMethod", local_var_param_value.to_string());
2970    }
2971    if let Some(local_var_param_value) = sip_registration {
2972        local_var_form_params.insert("SipRegistration", local_var_param_value.to_string());
2973    }
2974    if let Some(local_var_param_value) = emergency_calling_enabled {
2975        local_var_form_params.insert("EmergencyCallingEnabled", local_var_param_value.to_string());
2976    }
2977    if let Some(local_var_param_value) = secure {
2978        local_var_form_params.insert("Secure", local_var_param_value.to_string());
2979    }
2980    if let Some(local_var_param_value) = byoc_trunk_sid {
2981        local_var_form_params.insert("ByocTrunkSid", local_var_param_value.to_string());
2982    }
2983    if let Some(local_var_param_value) = emergency_caller_sid {
2984        local_var_form_params.insert("EmergencyCallerSid", local_var_param_value.to_string());
2985    }
2986    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
2987
2988    let local_var_req = local_var_req_builder.build()?;
2989    let local_var_resp = local_var_client.execute(local_var_req).await?;
2990
2991    let local_var_status = local_var_resp.status();
2992    let local_var_content = local_var_resp.text().await?;
2993
2994    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
2995        serde_json::from_str(&local_var_content).map_err(Error::from)
2996    } else {
2997        let local_var_entity: Option<CreateSipDomainError> = serde_json::from_str(&local_var_content).ok();
2998        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
2999        Err(Error::ResponseError(local_var_error))
3000    }
3001}
3002
3003/// Create a new IpAccessControlList resource
3004pub async fn create_sip_ip_access_control_list(configuration: &configuration::Configuration, account_sid: &str, friendly_name: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipIpAccessControlList, Error<CreateSipIpAccessControlListError>> {
3005    let local_var_configuration = configuration;
3006
3007    let local_var_client = &local_var_configuration.client;
3008
3009    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
3010    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3011
3012    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3013        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3014    }
3015    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
3016        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
3017    };
3018    let mut local_var_form_params = std::collections::HashMap::new();
3019    local_var_form_params.insert("FriendlyName", friendly_name.to_string());
3020    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
3021
3022    let local_var_req = local_var_req_builder.build()?;
3023    let local_var_resp = local_var_client.execute(local_var_req).await?;
3024
3025    let local_var_status = local_var_resp.status();
3026    let local_var_content = local_var_resp.text().await?;
3027
3028    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3029        serde_json::from_str(&local_var_content).map_err(Error::from)
3030    } else {
3031        let local_var_entity: Option<CreateSipIpAccessControlListError> = serde_json::from_str(&local_var_content).ok();
3032        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3033        Err(Error::ResponseError(local_var_error))
3034    }
3035}
3036
3037/// Create a new IpAccessControlListMapping resource.
3038pub async fn create_sip_ip_access_control_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, ip_access_control_list_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipIpAccessControlListMapping, Error<CreateSipIpAccessControlListMappingError>> {
3039    let local_var_configuration = configuration;
3040
3041    let local_var_client = &local_var_configuration.client;
3042
3043    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/IpAccessControlListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
3044    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3045
3046    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3047        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3048    }
3049    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
3050        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
3051    };
3052    let mut local_var_form_params = std::collections::HashMap::new();
3053    local_var_form_params.insert("IpAccessControlListSid", ip_access_control_list_sid.to_string());
3054    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
3055
3056    let local_var_req = local_var_req_builder.build()?;
3057    let local_var_resp = local_var_client.execute(local_var_req).await?;
3058
3059    let local_var_status = local_var_resp.status();
3060    let local_var_content = local_var_resp.text().await?;
3061
3062    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3063        serde_json::from_str(&local_var_content).map_err(Error::from)
3064    } else {
3065        let local_var_entity: Option<CreateSipIpAccessControlListMappingError> = serde_json::from_str(&local_var_content).ok();
3066        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3067        Err(Error::ResponseError(local_var_error))
3068    }
3069}
3070
3071/// Create a new IpAddress resource.
3072pub async fn create_sip_ip_address(configuration: &configuration::Configuration, account_sid: &str, ip_access_control_list_sid: &str, friendly_name: &str, ip_address: &str, cidr_prefix_length: Option<i32>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipIpAccessControlListPeriodSipIpAddress, Error<CreateSipIpAddressError>> {
3073    let local_var_configuration = configuration;
3074
3075    let local_var_client = &local_var_configuration.client;
3076
3077    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid));
3078    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3079
3080    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3081        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3082    }
3083    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
3084        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
3085    };
3086    let mut local_var_form_params = std::collections::HashMap::new();
3087    local_var_form_params.insert("FriendlyName", friendly_name.to_string());
3088    local_var_form_params.insert("IpAddress", ip_address.to_string());
3089    if let Some(local_var_param_value) = cidr_prefix_length {
3090        local_var_form_params.insert("CidrPrefixLength", local_var_param_value.to_string());
3091    }
3092    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
3093
3094    let local_var_req = local_var_req_builder.build()?;
3095    let local_var_resp = local_var_client.execute(local_var_req).await?;
3096
3097    let local_var_status = local_var_resp.status();
3098    let local_var_content = local_var_resp.text().await?;
3099
3100    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3101        serde_json::from_str(&local_var_content).map_err(Error::from)
3102    } else {
3103        let local_var_entity: Option<CreateSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
3104        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3105        Err(Error::ResponseError(local_var_error))
3106    }
3107}
3108
3109/// Create a Siprec
3110pub async fn create_siprec(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, name: Option<&str>, connector_name: Option<&str>, track: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, parameter1_period_name: Option<&str>, parameter1_period_value: Option<&str>, parameter2_period_name: Option<&str>, parameter2_period_value: Option<&str>, parameter3_period_name: Option<&str>, parameter3_period_value: Option<&str>, parameter4_period_name: Option<&str>, parameter4_period_value: Option<&str>, parameter5_period_name: Option<&str>, parameter5_period_value: Option<&str>, parameter6_period_name: Option<&str>, parameter6_period_value: Option<&str>, parameter7_period_name: Option<&str>, parameter7_period_value: Option<&str>, parameter8_period_name: Option<&str>, parameter8_period_value: Option<&str>, parameter9_period_name: Option<&str>, parameter9_period_value: Option<&str>, parameter10_period_name: Option<&str>, parameter10_period_value: Option<&str>, parameter11_period_name: Option<&str>, parameter11_period_value: Option<&str>, parameter12_period_name: Option<&str>, parameter12_period_value: Option<&str>, parameter13_period_name: Option<&str>, parameter13_period_value: Option<&str>, parameter14_period_name: Option<&str>, parameter14_period_value: Option<&str>, parameter15_period_name: Option<&str>, parameter15_period_value: Option<&str>, parameter16_period_name: Option<&str>, parameter16_period_value: Option<&str>, parameter17_period_name: Option<&str>, parameter17_period_value: Option<&str>, parameter18_period_name: Option<&str>, parameter18_period_value: Option<&str>, parameter19_period_name: Option<&str>, parameter19_period_value: Option<&str>, parameter20_period_name: Option<&str>, parameter20_period_value: Option<&str>, parameter21_period_name: Option<&str>, parameter21_period_value: Option<&str>, parameter22_period_name: Option<&str>, parameter22_period_value: Option<&str>, parameter23_period_name: Option<&str>, parameter23_period_value: Option<&str>, parameter24_period_name: Option<&str>, parameter24_period_value: Option<&str>, parameter25_period_name: Option<&str>, parameter25_period_value: Option<&str>, parameter26_period_name: Option<&str>, parameter26_period_value: Option<&str>, parameter27_period_name: Option<&str>, parameter27_period_value: Option<&str>, parameter28_period_name: Option<&str>, parameter28_period_value: Option<&str>, parameter29_period_name: Option<&str>, parameter29_period_value: Option<&str>, parameter30_period_name: Option<&str>, parameter30_period_value: Option<&str>, parameter31_period_name: Option<&str>, parameter31_period_value: Option<&str>, parameter32_period_name: Option<&str>, parameter32_period_value: Option<&str>, parameter33_period_name: Option<&str>, parameter33_period_value: Option<&str>, parameter34_period_name: Option<&str>, parameter34_period_value: Option<&str>, parameter35_period_name: Option<&str>, parameter35_period_value: Option<&str>, parameter36_period_name: Option<&str>, parameter36_period_value: Option<&str>, parameter37_period_name: Option<&str>, parameter37_period_value: Option<&str>, parameter38_period_name: Option<&str>, parameter38_period_value: Option<&str>, parameter39_period_name: Option<&str>, parameter39_period_value: Option<&str>, parameter40_period_name: Option<&str>, parameter40_period_value: Option<&str>, parameter41_period_name: Option<&str>, parameter41_period_value: Option<&str>, parameter42_period_name: Option<&str>, parameter42_period_value: Option<&str>, parameter43_period_name: Option<&str>, parameter43_period_value: Option<&str>, parameter44_period_name: Option<&str>, parameter44_period_value: Option<&str>, parameter45_period_name: Option<&str>, parameter45_period_value: Option<&str>, parameter46_period_name: Option<&str>, parameter46_period_value: Option<&str>, parameter47_period_name: Option<&str>, parameter47_period_value: Option<&str>, parameter48_period_name: Option<&str>, parameter48_period_value: Option<&str>, parameter49_period_name: Option<&str>, parameter49_period_value: Option<&str>, parameter50_period_name: Option<&str>, parameter50_period_value: Option<&str>, parameter51_period_name: Option<&str>, parameter51_period_value: Option<&str>, parameter52_period_name: Option<&str>, parameter52_period_value: Option<&str>, parameter53_period_name: Option<&str>, parameter53_period_value: Option<&str>, parameter54_period_name: Option<&str>, parameter54_period_value: Option<&str>, parameter55_period_name: Option<&str>, parameter55_period_value: Option<&str>, parameter56_period_name: Option<&str>, parameter56_period_value: Option<&str>, parameter57_period_name: Option<&str>, parameter57_period_value: Option<&str>, parameter58_period_name: Option<&str>, parameter58_period_value: Option<&str>, parameter59_period_name: Option<&str>, parameter59_period_value: Option<&str>, parameter60_period_name: Option<&str>, parameter60_period_value: Option<&str>, parameter61_period_name: Option<&str>, parameter61_period_value: Option<&str>, parameter62_period_name: Option<&str>, parameter62_period_value: Option<&str>, parameter63_period_name: Option<&str>, parameter63_period_value: Option<&str>, parameter64_period_name: Option<&str>, parameter64_period_value: Option<&str>, parameter65_period_name: Option<&str>, parameter65_period_value: Option<&str>, parameter66_period_name: Option<&str>, parameter66_period_value: Option<&str>, parameter67_period_name: Option<&str>, parameter67_period_value: Option<&str>, parameter68_period_name: Option<&str>, parameter68_period_value: Option<&str>, parameter69_period_name: Option<&str>, parameter69_period_value: Option<&str>, parameter70_period_name: Option<&str>, parameter70_period_value: Option<&str>, parameter71_period_name: Option<&str>, parameter71_period_value: Option<&str>, parameter72_period_name: Option<&str>, parameter72_period_value: Option<&str>, parameter73_period_name: Option<&str>, parameter73_period_value: Option<&str>, parameter74_period_name: Option<&str>, parameter74_period_value: Option<&str>, parameter75_period_name: Option<&str>, parameter75_period_value: Option<&str>, parameter76_period_name: Option<&str>, parameter76_period_value: Option<&str>, parameter77_period_name: Option<&str>, parameter77_period_value: Option<&str>, parameter78_period_name: Option<&str>, parameter78_period_value: Option<&str>, parameter79_period_name: Option<&str>, parameter79_period_value: Option<&str>, parameter80_period_name: Option<&str>, parameter80_period_value: Option<&str>, parameter81_period_name: Option<&str>, parameter81_period_value: Option<&str>, parameter82_period_name: Option<&str>, parameter82_period_value: Option<&str>, parameter83_period_name: Option<&str>, parameter83_period_value: Option<&str>, parameter84_period_name: Option<&str>, parameter84_period_value: Option<&str>, parameter85_period_name: Option<&str>, parameter85_period_value: Option<&str>, parameter86_period_name: Option<&str>, parameter86_period_value: Option<&str>, parameter87_period_name: Option<&str>, parameter87_period_value: Option<&str>, parameter88_period_name: Option<&str>, parameter88_period_value: Option<&str>, parameter89_period_name: Option<&str>, parameter89_period_value: Option<&str>, parameter90_period_name: Option<&str>, parameter90_period_value: Option<&str>, parameter91_period_name: Option<&str>, parameter91_period_value: Option<&str>, parameter92_period_name: Option<&str>, parameter92_period_value: Option<&str>, parameter93_period_name: Option<&str>, parameter93_period_value: Option<&str>, parameter94_period_name: Option<&str>, parameter94_period_value: Option<&str>, parameter95_period_name: Option<&str>, parameter95_period_value: Option<&str>, parameter96_period_name: Option<&str>, parameter96_period_value: Option<&str>, parameter97_period_name: Option<&str>, parameter97_period_value: Option<&str>, parameter98_period_name: Option<&str>, parameter98_period_value: Option<&str>, parameter99_period_name: Option<&str>, parameter99_period_value: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodSiprec, Error<CreateSiprecError>> {
3111    let local_var_configuration = configuration;
3112
3113    let local_var_client = &local_var_configuration.client;
3114
3115    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Siprec.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
3116    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3117
3118    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3119        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3120    }
3121    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
3122        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
3123    };
3124    let mut local_var_form_params = std::collections::HashMap::new();
3125    if let Some(local_var_param_value) = name {
3126        local_var_form_params.insert("Name", local_var_param_value.to_string());
3127    }
3128    if let Some(local_var_param_value) = connector_name {
3129        local_var_form_params.insert("ConnectorName", local_var_param_value.to_string());
3130    }
3131    if let Some(local_var_param_value) = track {
3132        local_var_form_params.insert("Track", local_var_param_value.to_string());
3133    }
3134    if let Some(local_var_param_value) = status_callback {
3135        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
3136    }
3137    if let Some(local_var_param_value) = status_callback_method {
3138        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
3139    }
3140    if let Some(local_var_param_value) = parameter1_period_name {
3141        local_var_form_params.insert("Parameter1.Name", local_var_param_value.to_string());
3142    }
3143    if let Some(local_var_param_value) = parameter1_period_value {
3144        local_var_form_params.insert("Parameter1.Value", local_var_param_value.to_string());
3145    }
3146    if let Some(local_var_param_value) = parameter2_period_name {
3147        local_var_form_params.insert("Parameter2.Name", local_var_param_value.to_string());
3148    }
3149    if let Some(local_var_param_value) = parameter2_period_value {
3150        local_var_form_params.insert("Parameter2.Value", local_var_param_value.to_string());
3151    }
3152    if let Some(local_var_param_value) = parameter3_period_name {
3153        local_var_form_params.insert("Parameter3.Name", local_var_param_value.to_string());
3154    }
3155    if let Some(local_var_param_value) = parameter3_period_value {
3156        local_var_form_params.insert("Parameter3.Value", local_var_param_value.to_string());
3157    }
3158    if let Some(local_var_param_value) = parameter4_period_name {
3159        local_var_form_params.insert("Parameter4.Name", local_var_param_value.to_string());
3160    }
3161    if let Some(local_var_param_value) = parameter4_period_value {
3162        local_var_form_params.insert("Parameter4.Value", local_var_param_value.to_string());
3163    }
3164    if let Some(local_var_param_value) = parameter5_period_name {
3165        local_var_form_params.insert("Parameter5.Name", local_var_param_value.to_string());
3166    }
3167    if let Some(local_var_param_value) = parameter5_period_value {
3168        local_var_form_params.insert("Parameter5.Value", local_var_param_value.to_string());
3169    }
3170    if let Some(local_var_param_value) = parameter6_period_name {
3171        local_var_form_params.insert("Parameter6.Name", local_var_param_value.to_string());
3172    }
3173    if let Some(local_var_param_value) = parameter6_period_value {
3174        local_var_form_params.insert("Parameter6.Value", local_var_param_value.to_string());
3175    }
3176    if let Some(local_var_param_value) = parameter7_period_name {
3177        local_var_form_params.insert("Parameter7.Name", local_var_param_value.to_string());
3178    }
3179    if let Some(local_var_param_value) = parameter7_period_value {
3180        local_var_form_params.insert("Parameter7.Value", local_var_param_value.to_string());
3181    }
3182    if let Some(local_var_param_value) = parameter8_period_name {
3183        local_var_form_params.insert("Parameter8.Name", local_var_param_value.to_string());
3184    }
3185    if let Some(local_var_param_value) = parameter8_period_value {
3186        local_var_form_params.insert("Parameter8.Value", local_var_param_value.to_string());
3187    }
3188    if let Some(local_var_param_value) = parameter9_period_name {
3189        local_var_form_params.insert("Parameter9.Name", local_var_param_value.to_string());
3190    }
3191    if let Some(local_var_param_value) = parameter9_period_value {
3192        local_var_form_params.insert("Parameter9.Value", local_var_param_value.to_string());
3193    }
3194    if let Some(local_var_param_value) = parameter10_period_name {
3195        local_var_form_params.insert("Parameter10.Name", local_var_param_value.to_string());
3196    }
3197    if let Some(local_var_param_value) = parameter10_period_value {
3198        local_var_form_params.insert("Parameter10.Value", local_var_param_value.to_string());
3199    }
3200    if let Some(local_var_param_value) = parameter11_period_name {
3201        local_var_form_params.insert("Parameter11.Name", local_var_param_value.to_string());
3202    }
3203    if let Some(local_var_param_value) = parameter11_period_value {
3204        local_var_form_params.insert("Parameter11.Value", local_var_param_value.to_string());
3205    }
3206    if let Some(local_var_param_value) = parameter12_period_name {
3207        local_var_form_params.insert("Parameter12.Name", local_var_param_value.to_string());
3208    }
3209    if let Some(local_var_param_value) = parameter12_period_value {
3210        local_var_form_params.insert("Parameter12.Value", local_var_param_value.to_string());
3211    }
3212    if let Some(local_var_param_value) = parameter13_period_name {
3213        local_var_form_params.insert("Parameter13.Name", local_var_param_value.to_string());
3214    }
3215    if let Some(local_var_param_value) = parameter13_period_value {
3216        local_var_form_params.insert("Parameter13.Value", local_var_param_value.to_string());
3217    }
3218    if let Some(local_var_param_value) = parameter14_period_name {
3219        local_var_form_params.insert("Parameter14.Name", local_var_param_value.to_string());
3220    }
3221    if let Some(local_var_param_value) = parameter14_period_value {
3222        local_var_form_params.insert("Parameter14.Value", local_var_param_value.to_string());
3223    }
3224    if let Some(local_var_param_value) = parameter15_period_name {
3225        local_var_form_params.insert("Parameter15.Name", local_var_param_value.to_string());
3226    }
3227    if let Some(local_var_param_value) = parameter15_period_value {
3228        local_var_form_params.insert("Parameter15.Value", local_var_param_value.to_string());
3229    }
3230    if let Some(local_var_param_value) = parameter16_period_name {
3231        local_var_form_params.insert("Parameter16.Name", local_var_param_value.to_string());
3232    }
3233    if let Some(local_var_param_value) = parameter16_period_value {
3234        local_var_form_params.insert("Parameter16.Value", local_var_param_value.to_string());
3235    }
3236    if let Some(local_var_param_value) = parameter17_period_name {
3237        local_var_form_params.insert("Parameter17.Name", local_var_param_value.to_string());
3238    }
3239    if let Some(local_var_param_value) = parameter17_period_value {
3240        local_var_form_params.insert("Parameter17.Value", local_var_param_value.to_string());
3241    }
3242    if let Some(local_var_param_value) = parameter18_period_name {
3243        local_var_form_params.insert("Parameter18.Name", local_var_param_value.to_string());
3244    }
3245    if let Some(local_var_param_value) = parameter18_period_value {
3246        local_var_form_params.insert("Parameter18.Value", local_var_param_value.to_string());
3247    }
3248    if let Some(local_var_param_value) = parameter19_period_name {
3249        local_var_form_params.insert("Parameter19.Name", local_var_param_value.to_string());
3250    }
3251    if let Some(local_var_param_value) = parameter19_period_value {
3252        local_var_form_params.insert("Parameter19.Value", local_var_param_value.to_string());
3253    }
3254    if let Some(local_var_param_value) = parameter20_period_name {
3255        local_var_form_params.insert("Parameter20.Name", local_var_param_value.to_string());
3256    }
3257    if let Some(local_var_param_value) = parameter20_period_value {
3258        local_var_form_params.insert("Parameter20.Value", local_var_param_value.to_string());
3259    }
3260    if let Some(local_var_param_value) = parameter21_period_name {
3261        local_var_form_params.insert("Parameter21.Name", local_var_param_value.to_string());
3262    }
3263    if let Some(local_var_param_value) = parameter21_period_value {
3264        local_var_form_params.insert("Parameter21.Value", local_var_param_value.to_string());
3265    }
3266    if let Some(local_var_param_value) = parameter22_period_name {
3267        local_var_form_params.insert("Parameter22.Name", local_var_param_value.to_string());
3268    }
3269    if let Some(local_var_param_value) = parameter22_period_value {
3270        local_var_form_params.insert("Parameter22.Value", local_var_param_value.to_string());
3271    }
3272    if let Some(local_var_param_value) = parameter23_period_name {
3273        local_var_form_params.insert("Parameter23.Name", local_var_param_value.to_string());
3274    }
3275    if let Some(local_var_param_value) = parameter23_period_value {
3276        local_var_form_params.insert("Parameter23.Value", local_var_param_value.to_string());
3277    }
3278    if let Some(local_var_param_value) = parameter24_period_name {
3279        local_var_form_params.insert("Parameter24.Name", local_var_param_value.to_string());
3280    }
3281    if let Some(local_var_param_value) = parameter24_period_value {
3282        local_var_form_params.insert("Parameter24.Value", local_var_param_value.to_string());
3283    }
3284    if let Some(local_var_param_value) = parameter25_period_name {
3285        local_var_form_params.insert("Parameter25.Name", local_var_param_value.to_string());
3286    }
3287    if let Some(local_var_param_value) = parameter25_period_value {
3288        local_var_form_params.insert("Parameter25.Value", local_var_param_value.to_string());
3289    }
3290    if let Some(local_var_param_value) = parameter26_period_name {
3291        local_var_form_params.insert("Parameter26.Name", local_var_param_value.to_string());
3292    }
3293    if let Some(local_var_param_value) = parameter26_period_value {
3294        local_var_form_params.insert("Parameter26.Value", local_var_param_value.to_string());
3295    }
3296    if let Some(local_var_param_value) = parameter27_period_name {
3297        local_var_form_params.insert("Parameter27.Name", local_var_param_value.to_string());
3298    }
3299    if let Some(local_var_param_value) = parameter27_period_value {
3300        local_var_form_params.insert("Parameter27.Value", local_var_param_value.to_string());
3301    }
3302    if let Some(local_var_param_value) = parameter28_period_name {
3303        local_var_form_params.insert("Parameter28.Name", local_var_param_value.to_string());
3304    }
3305    if let Some(local_var_param_value) = parameter28_period_value {
3306        local_var_form_params.insert("Parameter28.Value", local_var_param_value.to_string());
3307    }
3308    if let Some(local_var_param_value) = parameter29_period_name {
3309        local_var_form_params.insert("Parameter29.Name", local_var_param_value.to_string());
3310    }
3311    if let Some(local_var_param_value) = parameter29_period_value {
3312        local_var_form_params.insert("Parameter29.Value", local_var_param_value.to_string());
3313    }
3314    if let Some(local_var_param_value) = parameter30_period_name {
3315        local_var_form_params.insert("Parameter30.Name", local_var_param_value.to_string());
3316    }
3317    if let Some(local_var_param_value) = parameter30_period_value {
3318        local_var_form_params.insert("Parameter30.Value", local_var_param_value.to_string());
3319    }
3320    if let Some(local_var_param_value) = parameter31_period_name {
3321        local_var_form_params.insert("Parameter31.Name", local_var_param_value.to_string());
3322    }
3323    if let Some(local_var_param_value) = parameter31_period_value {
3324        local_var_form_params.insert("Parameter31.Value", local_var_param_value.to_string());
3325    }
3326    if let Some(local_var_param_value) = parameter32_period_name {
3327        local_var_form_params.insert("Parameter32.Name", local_var_param_value.to_string());
3328    }
3329    if let Some(local_var_param_value) = parameter32_period_value {
3330        local_var_form_params.insert("Parameter32.Value", local_var_param_value.to_string());
3331    }
3332    if let Some(local_var_param_value) = parameter33_period_name {
3333        local_var_form_params.insert("Parameter33.Name", local_var_param_value.to_string());
3334    }
3335    if let Some(local_var_param_value) = parameter33_period_value {
3336        local_var_form_params.insert("Parameter33.Value", local_var_param_value.to_string());
3337    }
3338    if let Some(local_var_param_value) = parameter34_period_name {
3339        local_var_form_params.insert("Parameter34.Name", local_var_param_value.to_string());
3340    }
3341    if let Some(local_var_param_value) = parameter34_period_value {
3342        local_var_form_params.insert("Parameter34.Value", local_var_param_value.to_string());
3343    }
3344    if let Some(local_var_param_value) = parameter35_period_name {
3345        local_var_form_params.insert("Parameter35.Name", local_var_param_value.to_string());
3346    }
3347    if let Some(local_var_param_value) = parameter35_period_value {
3348        local_var_form_params.insert("Parameter35.Value", local_var_param_value.to_string());
3349    }
3350    if let Some(local_var_param_value) = parameter36_period_name {
3351        local_var_form_params.insert("Parameter36.Name", local_var_param_value.to_string());
3352    }
3353    if let Some(local_var_param_value) = parameter36_period_value {
3354        local_var_form_params.insert("Parameter36.Value", local_var_param_value.to_string());
3355    }
3356    if let Some(local_var_param_value) = parameter37_period_name {
3357        local_var_form_params.insert("Parameter37.Name", local_var_param_value.to_string());
3358    }
3359    if let Some(local_var_param_value) = parameter37_period_value {
3360        local_var_form_params.insert("Parameter37.Value", local_var_param_value.to_string());
3361    }
3362    if let Some(local_var_param_value) = parameter38_period_name {
3363        local_var_form_params.insert("Parameter38.Name", local_var_param_value.to_string());
3364    }
3365    if let Some(local_var_param_value) = parameter38_period_value {
3366        local_var_form_params.insert("Parameter38.Value", local_var_param_value.to_string());
3367    }
3368    if let Some(local_var_param_value) = parameter39_period_name {
3369        local_var_form_params.insert("Parameter39.Name", local_var_param_value.to_string());
3370    }
3371    if let Some(local_var_param_value) = parameter39_period_value {
3372        local_var_form_params.insert("Parameter39.Value", local_var_param_value.to_string());
3373    }
3374    if let Some(local_var_param_value) = parameter40_period_name {
3375        local_var_form_params.insert("Parameter40.Name", local_var_param_value.to_string());
3376    }
3377    if let Some(local_var_param_value) = parameter40_period_value {
3378        local_var_form_params.insert("Parameter40.Value", local_var_param_value.to_string());
3379    }
3380    if let Some(local_var_param_value) = parameter41_period_name {
3381        local_var_form_params.insert("Parameter41.Name", local_var_param_value.to_string());
3382    }
3383    if let Some(local_var_param_value) = parameter41_period_value {
3384        local_var_form_params.insert("Parameter41.Value", local_var_param_value.to_string());
3385    }
3386    if let Some(local_var_param_value) = parameter42_period_name {
3387        local_var_form_params.insert("Parameter42.Name", local_var_param_value.to_string());
3388    }
3389    if let Some(local_var_param_value) = parameter42_period_value {
3390        local_var_form_params.insert("Parameter42.Value", local_var_param_value.to_string());
3391    }
3392    if let Some(local_var_param_value) = parameter43_period_name {
3393        local_var_form_params.insert("Parameter43.Name", local_var_param_value.to_string());
3394    }
3395    if let Some(local_var_param_value) = parameter43_period_value {
3396        local_var_form_params.insert("Parameter43.Value", local_var_param_value.to_string());
3397    }
3398    if let Some(local_var_param_value) = parameter44_period_name {
3399        local_var_form_params.insert("Parameter44.Name", local_var_param_value.to_string());
3400    }
3401    if let Some(local_var_param_value) = parameter44_period_value {
3402        local_var_form_params.insert("Parameter44.Value", local_var_param_value.to_string());
3403    }
3404    if let Some(local_var_param_value) = parameter45_period_name {
3405        local_var_form_params.insert("Parameter45.Name", local_var_param_value.to_string());
3406    }
3407    if let Some(local_var_param_value) = parameter45_period_value {
3408        local_var_form_params.insert("Parameter45.Value", local_var_param_value.to_string());
3409    }
3410    if let Some(local_var_param_value) = parameter46_period_name {
3411        local_var_form_params.insert("Parameter46.Name", local_var_param_value.to_string());
3412    }
3413    if let Some(local_var_param_value) = parameter46_period_value {
3414        local_var_form_params.insert("Parameter46.Value", local_var_param_value.to_string());
3415    }
3416    if let Some(local_var_param_value) = parameter47_period_name {
3417        local_var_form_params.insert("Parameter47.Name", local_var_param_value.to_string());
3418    }
3419    if let Some(local_var_param_value) = parameter47_period_value {
3420        local_var_form_params.insert("Parameter47.Value", local_var_param_value.to_string());
3421    }
3422    if let Some(local_var_param_value) = parameter48_period_name {
3423        local_var_form_params.insert("Parameter48.Name", local_var_param_value.to_string());
3424    }
3425    if let Some(local_var_param_value) = parameter48_period_value {
3426        local_var_form_params.insert("Parameter48.Value", local_var_param_value.to_string());
3427    }
3428    if let Some(local_var_param_value) = parameter49_period_name {
3429        local_var_form_params.insert("Parameter49.Name", local_var_param_value.to_string());
3430    }
3431    if let Some(local_var_param_value) = parameter49_period_value {
3432        local_var_form_params.insert("Parameter49.Value", local_var_param_value.to_string());
3433    }
3434    if let Some(local_var_param_value) = parameter50_period_name {
3435        local_var_form_params.insert("Parameter50.Name", local_var_param_value.to_string());
3436    }
3437    if let Some(local_var_param_value) = parameter50_period_value {
3438        local_var_form_params.insert("Parameter50.Value", local_var_param_value.to_string());
3439    }
3440    if let Some(local_var_param_value) = parameter51_period_name {
3441        local_var_form_params.insert("Parameter51.Name", local_var_param_value.to_string());
3442    }
3443    if let Some(local_var_param_value) = parameter51_period_value {
3444        local_var_form_params.insert("Parameter51.Value", local_var_param_value.to_string());
3445    }
3446    if let Some(local_var_param_value) = parameter52_period_name {
3447        local_var_form_params.insert("Parameter52.Name", local_var_param_value.to_string());
3448    }
3449    if let Some(local_var_param_value) = parameter52_period_value {
3450        local_var_form_params.insert("Parameter52.Value", local_var_param_value.to_string());
3451    }
3452    if let Some(local_var_param_value) = parameter53_period_name {
3453        local_var_form_params.insert("Parameter53.Name", local_var_param_value.to_string());
3454    }
3455    if let Some(local_var_param_value) = parameter53_period_value {
3456        local_var_form_params.insert("Parameter53.Value", local_var_param_value.to_string());
3457    }
3458    if let Some(local_var_param_value) = parameter54_period_name {
3459        local_var_form_params.insert("Parameter54.Name", local_var_param_value.to_string());
3460    }
3461    if let Some(local_var_param_value) = parameter54_period_value {
3462        local_var_form_params.insert("Parameter54.Value", local_var_param_value.to_string());
3463    }
3464    if let Some(local_var_param_value) = parameter55_period_name {
3465        local_var_form_params.insert("Parameter55.Name", local_var_param_value.to_string());
3466    }
3467    if let Some(local_var_param_value) = parameter55_period_value {
3468        local_var_form_params.insert("Parameter55.Value", local_var_param_value.to_string());
3469    }
3470    if let Some(local_var_param_value) = parameter56_period_name {
3471        local_var_form_params.insert("Parameter56.Name", local_var_param_value.to_string());
3472    }
3473    if let Some(local_var_param_value) = parameter56_period_value {
3474        local_var_form_params.insert("Parameter56.Value", local_var_param_value.to_string());
3475    }
3476    if let Some(local_var_param_value) = parameter57_period_name {
3477        local_var_form_params.insert("Parameter57.Name", local_var_param_value.to_string());
3478    }
3479    if let Some(local_var_param_value) = parameter57_period_value {
3480        local_var_form_params.insert("Parameter57.Value", local_var_param_value.to_string());
3481    }
3482    if let Some(local_var_param_value) = parameter58_period_name {
3483        local_var_form_params.insert("Parameter58.Name", local_var_param_value.to_string());
3484    }
3485    if let Some(local_var_param_value) = parameter58_period_value {
3486        local_var_form_params.insert("Parameter58.Value", local_var_param_value.to_string());
3487    }
3488    if let Some(local_var_param_value) = parameter59_period_name {
3489        local_var_form_params.insert("Parameter59.Name", local_var_param_value.to_string());
3490    }
3491    if let Some(local_var_param_value) = parameter59_period_value {
3492        local_var_form_params.insert("Parameter59.Value", local_var_param_value.to_string());
3493    }
3494    if let Some(local_var_param_value) = parameter60_period_name {
3495        local_var_form_params.insert("Parameter60.Name", local_var_param_value.to_string());
3496    }
3497    if let Some(local_var_param_value) = parameter60_period_value {
3498        local_var_form_params.insert("Parameter60.Value", local_var_param_value.to_string());
3499    }
3500    if let Some(local_var_param_value) = parameter61_period_name {
3501        local_var_form_params.insert("Parameter61.Name", local_var_param_value.to_string());
3502    }
3503    if let Some(local_var_param_value) = parameter61_period_value {
3504        local_var_form_params.insert("Parameter61.Value", local_var_param_value.to_string());
3505    }
3506    if let Some(local_var_param_value) = parameter62_period_name {
3507        local_var_form_params.insert("Parameter62.Name", local_var_param_value.to_string());
3508    }
3509    if let Some(local_var_param_value) = parameter62_period_value {
3510        local_var_form_params.insert("Parameter62.Value", local_var_param_value.to_string());
3511    }
3512    if let Some(local_var_param_value) = parameter63_period_name {
3513        local_var_form_params.insert("Parameter63.Name", local_var_param_value.to_string());
3514    }
3515    if let Some(local_var_param_value) = parameter63_period_value {
3516        local_var_form_params.insert("Parameter63.Value", local_var_param_value.to_string());
3517    }
3518    if let Some(local_var_param_value) = parameter64_period_name {
3519        local_var_form_params.insert("Parameter64.Name", local_var_param_value.to_string());
3520    }
3521    if let Some(local_var_param_value) = parameter64_period_value {
3522        local_var_form_params.insert("Parameter64.Value", local_var_param_value.to_string());
3523    }
3524    if let Some(local_var_param_value) = parameter65_period_name {
3525        local_var_form_params.insert("Parameter65.Name", local_var_param_value.to_string());
3526    }
3527    if let Some(local_var_param_value) = parameter65_period_value {
3528        local_var_form_params.insert("Parameter65.Value", local_var_param_value.to_string());
3529    }
3530    if let Some(local_var_param_value) = parameter66_period_name {
3531        local_var_form_params.insert("Parameter66.Name", local_var_param_value.to_string());
3532    }
3533    if let Some(local_var_param_value) = parameter66_period_value {
3534        local_var_form_params.insert("Parameter66.Value", local_var_param_value.to_string());
3535    }
3536    if let Some(local_var_param_value) = parameter67_period_name {
3537        local_var_form_params.insert("Parameter67.Name", local_var_param_value.to_string());
3538    }
3539    if let Some(local_var_param_value) = parameter67_period_value {
3540        local_var_form_params.insert("Parameter67.Value", local_var_param_value.to_string());
3541    }
3542    if let Some(local_var_param_value) = parameter68_period_name {
3543        local_var_form_params.insert("Parameter68.Name", local_var_param_value.to_string());
3544    }
3545    if let Some(local_var_param_value) = parameter68_period_value {
3546        local_var_form_params.insert("Parameter68.Value", local_var_param_value.to_string());
3547    }
3548    if let Some(local_var_param_value) = parameter69_period_name {
3549        local_var_form_params.insert("Parameter69.Name", local_var_param_value.to_string());
3550    }
3551    if let Some(local_var_param_value) = parameter69_period_value {
3552        local_var_form_params.insert("Parameter69.Value", local_var_param_value.to_string());
3553    }
3554    if let Some(local_var_param_value) = parameter70_period_name {
3555        local_var_form_params.insert("Parameter70.Name", local_var_param_value.to_string());
3556    }
3557    if let Some(local_var_param_value) = parameter70_period_value {
3558        local_var_form_params.insert("Parameter70.Value", local_var_param_value.to_string());
3559    }
3560    if let Some(local_var_param_value) = parameter71_period_name {
3561        local_var_form_params.insert("Parameter71.Name", local_var_param_value.to_string());
3562    }
3563    if let Some(local_var_param_value) = parameter71_period_value {
3564        local_var_form_params.insert("Parameter71.Value", local_var_param_value.to_string());
3565    }
3566    if let Some(local_var_param_value) = parameter72_period_name {
3567        local_var_form_params.insert("Parameter72.Name", local_var_param_value.to_string());
3568    }
3569    if let Some(local_var_param_value) = parameter72_period_value {
3570        local_var_form_params.insert("Parameter72.Value", local_var_param_value.to_string());
3571    }
3572    if let Some(local_var_param_value) = parameter73_period_name {
3573        local_var_form_params.insert("Parameter73.Name", local_var_param_value.to_string());
3574    }
3575    if let Some(local_var_param_value) = parameter73_period_value {
3576        local_var_form_params.insert("Parameter73.Value", local_var_param_value.to_string());
3577    }
3578    if let Some(local_var_param_value) = parameter74_period_name {
3579        local_var_form_params.insert("Parameter74.Name", local_var_param_value.to_string());
3580    }
3581    if let Some(local_var_param_value) = parameter74_period_value {
3582        local_var_form_params.insert("Parameter74.Value", local_var_param_value.to_string());
3583    }
3584    if let Some(local_var_param_value) = parameter75_period_name {
3585        local_var_form_params.insert("Parameter75.Name", local_var_param_value.to_string());
3586    }
3587    if let Some(local_var_param_value) = parameter75_period_value {
3588        local_var_form_params.insert("Parameter75.Value", local_var_param_value.to_string());
3589    }
3590    if let Some(local_var_param_value) = parameter76_period_name {
3591        local_var_form_params.insert("Parameter76.Name", local_var_param_value.to_string());
3592    }
3593    if let Some(local_var_param_value) = parameter76_period_value {
3594        local_var_form_params.insert("Parameter76.Value", local_var_param_value.to_string());
3595    }
3596    if let Some(local_var_param_value) = parameter77_period_name {
3597        local_var_form_params.insert("Parameter77.Name", local_var_param_value.to_string());
3598    }
3599    if let Some(local_var_param_value) = parameter77_period_value {
3600        local_var_form_params.insert("Parameter77.Value", local_var_param_value.to_string());
3601    }
3602    if let Some(local_var_param_value) = parameter78_period_name {
3603        local_var_form_params.insert("Parameter78.Name", local_var_param_value.to_string());
3604    }
3605    if let Some(local_var_param_value) = parameter78_period_value {
3606        local_var_form_params.insert("Parameter78.Value", local_var_param_value.to_string());
3607    }
3608    if let Some(local_var_param_value) = parameter79_period_name {
3609        local_var_form_params.insert("Parameter79.Name", local_var_param_value.to_string());
3610    }
3611    if let Some(local_var_param_value) = parameter79_period_value {
3612        local_var_form_params.insert("Parameter79.Value", local_var_param_value.to_string());
3613    }
3614    if let Some(local_var_param_value) = parameter80_period_name {
3615        local_var_form_params.insert("Parameter80.Name", local_var_param_value.to_string());
3616    }
3617    if let Some(local_var_param_value) = parameter80_period_value {
3618        local_var_form_params.insert("Parameter80.Value", local_var_param_value.to_string());
3619    }
3620    if let Some(local_var_param_value) = parameter81_period_name {
3621        local_var_form_params.insert("Parameter81.Name", local_var_param_value.to_string());
3622    }
3623    if let Some(local_var_param_value) = parameter81_period_value {
3624        local_var_form_params.insert("Parameter81.Value", local_var_param_value.to_string());
3625    }
3626    if let Some(local_var_param_value) = parameter82_period_name {
3627        local_var_form_params.insert("Parameter82.Name", local_var_param_value.to_string());
3628    }
3629    if let Some(local_var_param_value) = parameter82_period_value {
3630        local_var_form_params.insert("Parameter82.Value", local_var_param_value.to_string());
3631    }
3632    if let Some(local_var_param_value) = parameter83_period_name {
3633        local_var_form_params.insert("Parameter83.Name", local_var_param_value.to_string());
3634    }
3635    if let Some(local_var_param_value) = parameter83_period_value {
3636        local_var_form_params.insert("Parameter83.Value", local_var_param_value.to_string());
3637    }
3638    if let Some(local_var_param_value) = parameter84_period_name {
3639        local_var_form_params.insert("Parameter84.Name", local_var_param_value.to_string());
3640    }
3641    if let Some(local_var_param_value) = parameter84_period_value {
3642        local_var_form_params.insert("Parameter84.Value", local_var_param_value.to_string());
3643    }
3644    if let Some(local_var_param_value) = parameter85_period_name {
3645        local_var_form_params.insert("Parameter85.Name", local_var_param_value.to_string());
3646    }
3647    if let Some(local_var_param_value) = parameter85_period_value {
3648        local_var_form_params.insert("Parameter85.Value", local_var_param_value.to_string());
3649    }
3650    if let Some(local_var_param_value) = parameter86_period_name {
3651        local_var_form_params.insert("Parameter86.Name", local_var_param_value.to_string());
3652    }
3653    if let Some(local_var_param_value) = parameter86_period_value {
3654        local_var_form_params.insert("Parameter86.Value", local_var_param_value.to_string());
3655    }
3656    if let Some(local_var_param_value) = parameter87_period_name {
3657        local_var_form_params.insert("Parameter87.Name", local_var_param_value.to_string());
3658    }
3659    if let Some(local_var_param_value) = parameter87_period_value {
3660        local_var_form_params.insert("Parameter87.Value", local_var_param_value.to_string());
3661    }
3662    if let Some(local_var_param_value) = parameter88_period_name {
3663        local_var_form_params.insert("Parameter88.Name", local_var_param_value.to_string());
3664    }
3665    if let Some(local_var_param_value) = parameter88_period_value {
3666        local_var_form_params.insert("Parameter88.Value", local_var_param_value.to_string());
3667    }
3668    if let Some(local_var_param_value) = parameter89_period_name {
3669        local_var_form_params.insert("Parameter89.Name", local_var_param_value.to_string());
3670    }
3671    if let Some(local_var_param_value) = parameter89_period_value {
3672        local_var_form_params.insert("Parameter89.Value", local_var_param_value.to_string());
3673    }
3674    if let Some(local_var_param_value) = parameter90_period_name {
3675        local_var_form_params.insert("Parameter90.Name", local_var_param_value.to_string());
3676    }
3677    if let Some(local_var_param_value) = parameter90_period_value {
3678        local_var_form_params.insert("Parameter90.Value", local_var_param_value.to_string());
3679    }
3680    if let Some(local_var_param_value) = parameter91_period_name {
3681        local_var_form_params.insert("Parameter91.Name", local_var_param_value.to_string());
3682    }
3683    if let Some(local_var_param_value) = parameter91_period_value {
3684        local_var_form_params.insert("Parameter91.Value", local_var_param_value.to_string());
3685    }
3686    if let Some(local_var_param_value) = parameter92_period_name {
3687        local_var_form_params.insert("Parameter92.Name", local_var_param_value.to_string());
3688    }
3689    if let Some(local_var_param_value) = parameter92_period_value {
3690        local_var_form_params.insert("Parameter92.Value", local_var_param_value.to_string());
3691    }
3692    if let Some(local_var_param_value) = parameter93_period_name {
3693        local_var_form_params.insert("Parameter93.Name", local_var_param_value.to_string());
3694    }
3695    if let Some(local_var_param_value) = parameter93_period_value {
3696        local_var_form_params.insert("Parameter93.Value", local_var_param_value.to_string());
3697    }
3698    if let Some(local_var_param_value) = parameter94_period_name {
3699        local_var_form_params.insert("Parameter94.Name", local_var_param_value.to_string());
3700    }
3701    if let Some(local_var_param_value) = parameter94_period_value {
3702        local_var_form_params.insert("Parameter94.Value", local_var_param_value.to_string());
3703    }
3704    if let Some(local_var_param_value) = parameter95_period_name {
3705        local_var_form_params.insert("Parameter95.Name", local_var_param_value.to_string());
3706    }
3707    if let Some(local_var_param_value) = parameter95_period_value {
3708        local_var_form_params.insert("Parameter95.Value", local_var_param_value.to_string());
3709    }
3710    if let Some(local_var_param_value) = parameter96_period_name {
3711        local_var_form_params.insert("Parameter96.Name", local_var_param_value.to_string());
3712    }
3713    if let Some(local_var_param_value) = parameter96_period_value {
3714        local_var_form_params.insert("Parameter96.Value", local_var_param_value.to_string());
3715    }
3716    if let Some(local_var_param_value) = parameter97_period_name {
3717        local_var_form_params.insert("Parameter97.Name", local_var_param_value.to_string());
3718    }
3719    if let Some(local_var_param_value) = parameter97_period_value {
3720        local_var_form_params.insert("Parameter97.Value", local_var_param_value.to_string());
3721    }
3722    if let Some(local_var_param_value) = parameter98_period_name {
3723        local_var_form_params.insert("Parameter98.Name", local_var_param_value.to_string());
3724    }
3725    if let Some(local_var_param_value) = parameter98_period_value {
3726        local_var_form_params.insert("Parameter98.Value", local_var_param_value.to_string());
3727    }
3728    if let Some(local_var_param_value) = parameter99_period_name {
3729        local_var_form_params.insert("Parameter99.Name", local_var_param_value.to_string());
3730    }
3731    if let Some(local_var_param_value) = parameter99_period_value {
3732        local_var_form_params.insert("Parameter99.Value", local_var_param_value.to_string());
3733    }
3734    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
3735
3736    let local_var_req = local_var_req_builder.build()?;
3737    let local_var_resp = local_var_client.execute(local_var_req).await?;
3738
3739    let local_var_status = local_var_resp.status();
3740    let local_var_content = local_var_resp.text().await?;
3741
3742    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
3743        serde_json::from_str(&local_var_content).map_err(Error::from)
3744    } else {
3745        let local_var_entity: Option<CreateSiprecError> = serde_json::from_str(&local_var_content).ok();
3746        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
3747        Err(Error::ResponseError(local_var_error))
3748    }
3749}
3750
3751/// Create a Stream
3752pub async fn create_stream(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, url: &str, name: Option<&str>, track: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, parameter1_period_name: Option<&str>, parameter1_period_value: Option<&str>, parameter2_period_name: Option<&str>, parameter2_period_value: Option<&str>, parameter3_period_name: Option<&str>, parameter3_period_value: Option<&str>, parameter4_period_name: Option<&str>, parameter4_period_value: Option<&str>, parameter5_period_name: Option<&str>, parameter5_period_value: Option<&str>, parameter6_period_name: Option<&str>, parameter6_period_value: Option<&str>, parameter7_period_name: Option<&str>, parameter7_period_value: Option<&str>, parameter8_period_name: Option<&str>, parameter8_period_value: Option<&str>, parameter9_period_name: Option<&str>, parameter9_period_value: Option<&str>, parameter10_period_name: Option<&str>, parameter10_period_value: Option<&str>, parameter11_period_name: Option<&str>, parameter11_period_value: Option<&str>, parameter12_period_name: Option<&str>, parameter12_period_value: Option<&str>, parameter13_period_name: Option<&str>, parameter13_period_value: Option<&str>, parameter14_period_name: Option<&str>, parameter14_period_value: Option<&str>, parameter15_period_name: Option<&str>, parameter15_period_value: Option<&str>, parameter16_period_name: Option<&str>, parameter16_period_value: Option<&str>, parameter17_period_name: Option<&str>, parameter17_period_value: Option<&str>, parameter18_period_name: Option<&str>, parameter18_period_value: Option<&str>, parameter19_period_name: Option<&str>, parameter19_period_value: Option<&str>, parameter20_period_name: Option<&str>, parameter20_period_value: Option<&str>, parameter21_period_name: Option<&str>, parameter21_period_value: Option<&str>, parameter22_period_name: Option<&str>, parameter22_period_value: Option<&str>, parameter23_period_name: Option<&str>, parameter23_period_value: Option<&str>, parameter24_period_name: Option<&str>, parameter24_period_value: Option<&str>, parameter25_period_name: Option<&str>, parameter25_period_value: Option<&str>, parameter26_period_name: Option<&str>, parameter26_period_value: Option<&str>, parameter27_period_name: Option<&str>, parameter27_period_value: Option<&str>, parameter28_period_name: Option<&str>, parameter28_period_value: Option<&str>, parameter29_period_name: Option<&str>, parameter29_period_value: Option<&str>, parameter30_period_name: Option<&str>, parameter30_period_value: Option<&str>, parameter31_period_name: Option<&str>, parameter31_period_value: Option<&str>, parameter32_period_name: Option<&str>, parameter32_period_value: Option<&str>, parameter33_period_name: Option<&str>, parameter33_period_value: Option<&str>, parameter34_period_name: Option<&str>, parameter34_period_value: Option<&str>, parameter35_period_name: Option<&str>, parameter35_period_value: Option<&str>, parameter36_period_name: Option<&str>, parameter36_period_value: Option<&str>, parameter37_period_name: Option<&str>, parameter37_period_value: Option<&str>, parameter38_period_name: Option<&str>, parameter38_period_value: Option<&str>, parameter39_period_name: Option<&str>, parameter39_period_value: Option<&str>, parameter40_period_name: Option<&str>, parameter40_period_value: Option<&str>, parameter41_period_name: Option<&str>, parameter41_period_value: Option<&str>, parameter42_period_name: Option<&str>, parameter42_period_value: Option<&str>, parameter43_period_name: Option<&str>, parameter43_period_value: Option<&str>, parameter44_period_name: Option<&str>, parameter44_period_value: Option<&str>, parameter45_period_name: Option<&str>, parameter45_period_value: Option<&str>, parameter46_period_name: Option<&str>, parameter46_period_value: Option<&str>, parameter47_period_name: Option<&str>, parameter47_period_value: Option<&str>, parameter48_period_name: Option<&str>, parameter48_period_value: Option<&str>, parameter49_period_name: Option<&str>, parameter49_period_value: Option<&str>, parameter50_period_name: Option<&str>, parameter50_period_value: Option<&str>, parameter51_period_name: Option<&str>, parameter51_period_value: Option<&str>, parameter52_period_name: Option<&str>, parameter52_period_value: Option<&str>, parameter53_period_name: Option<&str>, parameter53_period_value: Option<&str>, parameter54_period_name: Option<&str>, parameter54_period_value: Option<&str>, parameter55_period_name: Option<&str>, parameter55_period_value: Option<&str>, parameter56_period_name: Option<&str>, parameter56_period_value: Option<&str>, parameter57_period_name: Option<&str>, parameter57_period_value: Option<&str>, parameter58_period_name: Option<&str>, parameter58_period_value: Option<&str>, parameter59_period_name: Option<&str>, parameter59_period_value: Option<&str>, parameter60_period_name: Option<&str>, parameter60_period_value: Option<&str>, parameter61_period_name: Option<&str>, parameter61_period_value: Option<&str>, parameter62_period_name: Option<&str>, parameter62_period_value: Option<&str>, parameter63_period_name: Option<&str>, parameter63_period_value: Option<&str>, parameter64_period_name: Option<&str>, parameter64_period_value: Option<&str>, parameter65_period_name: Option<&str>, parameter65_period_value: Option<&str>, parameter66_period_name: Option<&str>, parameter66_period_value: Option<&str>, parameter67_period_name: Option<&str>, parameter67_period_value: Option<&str>, parameter68_period_name: Option<&str>, parameter68_period_value: Option<&str>, parameter69_period_name: Option<&str>, parameter69_period_value: Option<&str>, parameter70_period_name: Option<&str>, parameter70_period_value: Option<&str>, parameter71_period_name: Option<&str>, parameter71_period_value: Option<&str>, parameter72_period_name: Option<&str>, parameter72_period_value: Option<&str>, parameter73_period_name: Option<&str>, parameter73_period_value: Option<&str>, parameter74_period_name: Option<&str>, parameter74_period_value: Option<&str>, parameter75_period_name: Option<&str>, parameter75_period_value: Option<&str>, parameter76_period_name: Option<&str>, parameter76_period_value: Option<&str>, parameter77_period_name: Option<&str>, parameter77_period_value: Option<&str>, parameter78_period_name: Option<&str>, parameter78_period_value: Option<&str>, parameter79_period_name: Option<&str>, parameter79_period_value: Option<&str>, parameter80_period_name: Option<&str>, parameter80_period_value: Option<&str>, parameter81_period_name: Option<&str>, parameter81_period_value: Option<&str>, parameter82_period_name: Option<&str>, parameter82_period_value: Option<&str>, parameter83_period_name: Option<&str>, parameter83_period_value: Option<&str>, parameter84_period_name: Option<&str>, parameter84_period_value: Option<&str>, parameter85_period_name: Option<&str>, parameter85_period_value: Option<&str>, parameter86_period_name: Option<&str>, parameter86_period_value: Option<&str>, parameter87_period_name: Option<&str>, parameter87_period_value: Option<&str>, parameter88_period_name: Option<&str>, parameter88_period_value: Option<&str>, parameter89_period_name: Option<&str>, parameter89_period_value: Option<&str>, parameter90_period_name: Option<&str>, parameter90_period_value: Option<&str>, parameter91_period_name: Option<&str>, parameter91_period_value: Option<&str>, parameter92_period_name: Option<&str>, parameter92_period_value: Option<&str>, parameter93_period_name: Option<&str>, parameter93_period_value: Option<&str>, parameter94_period_name: Option<&str>, parameter94_period_value: Option<&str>, parameter95_period_name: Option<&str>, parameter95_period_value: Option<&str>, parameter96_period_name: Option<&str>, parameter96_period_value: Option<&str>, parameter97_period_name: Option<&str>, parameter97_period_value: Option<&str>, parameter98_period_name: Option<&str>, parameter98_period_value: Option<&str>, parameter99_period_name: Option<&str>, parameter99_period_value: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodStream, Error<CreateStreamError>> {
3753    let local_var_configuration = configuration;
3754
3755    let local_var_client = &local_var_configuration.client;
3756
3757    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Streams.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
3758    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
3759
3760    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
3761        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
3762    }
3763    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
3764        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
3765    };
3766    let mut local_var_form_params = std::collections::HashMap::new();
3767    local_var_form_params.insert("Url", url.to_string());
3768    if let Some(local_var_param_value) = name {
3769        local_var_form_params.insert("Name", local_var_param_value.to_string());
3770    }
3771    if let Some(local_var_param_value) = track {
3772        local_var_form_params.insert("Track", local_var_param_value.to_string());
3773    }
3774    if let Some(local_var_param_value) = status_callback {
3775        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
3776    }
3777    if let Some(local_var_param_value) = status_callback_method {
3778        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
3779    }
3780    if let Some(local_var_param_value) = parameter1_period_name {
3781        local_var_form_params.insert("Parameter1.Name", local_var_param_value.to_string());
3782    }
3783    if let Some(local_var_param_value) = parameter1_period_value {
3784        local_var_form_params.insert("Parameter1.Value", local_var_param_value.to_string());
3785    }
3786    if let Some(local_var_param_value) = parameter2_period_name {
3787        local_var_form_params.insert("Parameter2.Name", local_var_param_value.to_string());
3788    }
3789    if let Some(local_var_param_value) = parameter2_period_value {
3790        local_var_form_params.insert("Parameter2.Value", local_var_param_value.to_string());
3791    }
3792    if let Some(local_var_param_value) = parameter3_period_name {
3793        local_var_form_params.insert("Parameter3.Name", local_var_param_value.to_string());
3794    }
3795    if let Some(local_var_param_value) = parameter3_period_value {
3796        local_var_form_params.insert("Parameter3.Value", local_var_param_value.to_string());
3797    }
3798    if let Some(local_var_param_value) = parameter4_period_name {
3799        local_var_form_params.insert("Parameter4.Name", local_var_param_value.to_string());
3800    }
3801    if let Some(local_var_param_value) = parameter4_period_value {
3802        local_var_form_params.insert("Parameter4.Value", local_var_param_value.to_string());
3803    }
3804    if let Some(local_var_param_value) = parameter5_period_name {
3805        local_var_form_params.insert("Parameter5.Name", local_var_param_value.to_string());
3806    }
3807    if let Some(local_var_param_value) = parameter5_period_value {
3808        local_var_form_params.insert("Parameter5.Value", local_var_param_value.to_string());
3809    }
3810    if let Some(local_var_param_value) = parameter6_period_name {
3811        local_var_form_params.insert("Parameter6.Name", local_var_param_value.to_string());
3812    }
3813    if let Some(local_var_param_value) = parameter6_period_value {
3814        local_var_form_params.insert("Parameter6.Value", local_var_param_value.to_string());
3815    }
3816    if let Some(local_var_param_value) = parameter7_period_name {
3817        local_var_form_params.insert("Parameter7.Name", local_var_param_value.to_string());
3818    }
3819    if let Some(local_var_param_value) = parameter7_period_value {
3820        local_var_form_params.insert("Parameter7.Value", local_var_param_value.to_string());
3821    }
3822    if let Some(local_var_param_value) = parameter8_period_name {
3823        local_var_form_params.insert("Parameter8.Name", local_var_param_value.to_string());
3824    }
3825    if let Some(local_var_param_value) = parameter8_period_value {
3826        local_var_form_params.insert("Parameter8.Value", local_var_param_value.to_string());
3827    }
3828    if let Some(local_var_param_value) = parameter9_period_name {
3829        local_var_form_params.insert("Parameter9.Name", local_var_param_value.to_string());
3830    }
3831    if let Some(local_var_param_value) = parameter9_period_value {
3832        local_var_form_params.insert("Parameter9.Value", local_var_param_value.to_string());
3833    }
3834    if let Some(local_var_param_value) = parameter10_period_name {
3835        local_var_form_params.insert("Parameter10.Name", local_var_param_value.to_string());
3836    }
3837    if let Some(local_var_param_value) = parameter10_period_value {
3838        local_var_form_params.insert("Parameter10.Value", local_var_param_value.to_string());
3839    }
3840    if let Some(local_var_param_value) = parameter11_period_name {
3841        local_var_form_params.insert("Parameter11.Name", local_var_param_value.to_string());
3842    }
3843    if let Some(local_var_param_value) = parameter11_period_value {
3844        local_var_form_params.insert("Parameter11.Value", local_var_param_value.to_string());
3845    }
3846    if let Some(local_var_param_value) = parameter12_period_name {
3847        local_var_form_params.insert("Parameter12.Name", local_var_param_value.to_string());
3848    }
3849    if let Some(local_var_param_value) = parameter12_period_value {
3850        local_var_form_params.insert("Parameter12.Value", local_var_param_value.to_string());
3851    }
3852    if let Some(local_var_param_value) = parameter13_period_name {
3853        local_var_form_params.insert("Parameter13.Name", local_var_param_value.to_string());
3854    }
3855    if let Some(local_var_param_value) = parameter13_period_value {
3856        local_var_form_params.insert("Parameter13.Value", local_var_param_value.to_string());
3857    }
3858    if let Some(local_var_param_value) = parameter14_period_name {
3859        local_var_form_params.insert("Parameter14.Name", local_var_param_value.to_string());
3860    }
3861    if let Some(local_var_param_value) = parameter14_period_value {
3862        local_var_form_params.insert("Parameter14.Value", local_var_param_value.to_string());
3863    }
3864    if let Some(local_var_param_value) = parameter15_period_name {
3865        local_var_form_params.insert("Parameter15.Name", local_var_param_value.to_string());
3866    }
3867    if let Some(local_var_param_value) = parameter15_period_value {
3868        local_var_form_params.insert("Parameter15.Value", local_var_param_value.to_string());
3869    }
3870    if let Some(local_var_param_value) = parameter16_period_name {
3871        local_var_form_params.insert("Parameter16.Name", local_var_param_value.to_string());
3872    }
3873    if let Some(local_var_param_value) = parameter16_period_value {
3874        local_var_form_params.insert("Parameter16.Value", local_var_param_value.to_string());
3875    }
3876    if let Some(local_var_param_value) = parameter17_period_name {
3877        local_var_form_params.insert("Parameter17.Name", local_var_param_value.to_string());
3878    }
3879    if let Some(local_var_param_value) = parameter17_period_value {
3880        local_var_form_params.insert("Parameter17.Value", local_var_param_value.to_string());
3881    }
3882    if let Some(local_var_param_value) = parameter18_period_name {
3883        local_var_form_params.insert("Parameter18.Name", local_var_param_value.to_string());
3884    }
3885    if let Some(local_var_param_value) = parameter18_period_value {
3886        local_var_form_params.insert("Parameter18.Value", local_var_param_value.to_string());
3887    }
3888    if let Some(local_var_param_value) = parameter19_period_name {
3889        local_var_form_params.insert("Parameter19.Name", local_var_param_value.to_string());
3890    }
3891    if let Some(local_var_param_value) = parameter19_period_value {
3892        local_var_form_params.insert("Parameter19.Value", local_var_param_value.to_string());
3893    }
3894    if let Some(local_var_param_value) = parameter20_period_name {
3895        local_var_form_params.insert("Parameter20.Name", local_var_param_value.to_string());
3896    }
3897    if let Some(local_var_param_value) = parameter20_period_value {
3898        local_var_form_params.insert("Parameter20.Value", local_var_param_value.to_string());
3899    }
3900    if let Some(local_var_param_value) = parameter21_period_name {
3901        local_var_form_params.insert("Parameter21.Name", local_var_param_value.to_string());
3902    }
3903    if let Some(local_var_param_value) = parameter21_period_value {
3904        local_var_form_params.insert("Parameter21.Value", local_var_param_value.to_string());
3905    }
3906    if let Some(local_var_param_value) = parameter22_period_name {
3907        local_var_form_params.insert("Parameter22.Name", local_var_param_value.to_string());
3908    }
3909    if let Some(local_var_param_value) = parameter22_period_value {
3910        local_var_form_params.insert("Parameter22.Value", local_var_param_value.to_string());
3911    }
3912    if let Some(local_var_param_value) = parameter23_period_name {
3913        local_var_form_params.insert("Parameter23.Name", local_var_param_value.to_string());
3914    }
3915    if let Some(local_var_param_value) = parameter23_period_value {
3916        local_var_form_params.insert("Parameter23.Value", local_var_param_value.to_string());
3917    }
3918    if let Some(local_var_param_value) = parameter24_period_name {
3919        local_var_form_params.insert("Parameter24.Name", local_var_param_value.to_string());
3920    }
3921    if let Some(local_var_param_value) = parameter24_period_value {
3922        local_var_form_params.insert("Parameter24.Value", local_var_param_value.to_string());
3923    }
3924    if let Some(local_var_param_value) = parameter25_period_name {
3925        local_var_form_params.insert("Parameter25.Name", local_var_param_value.to_string());
3926    }
3927    if let Some(local_var_param_value) = parameter25_period_value {
3928        local_var_form_params.insert("Parameter25.Value", local_var_param_value.to_string());
3929    }
3930    if let Some(local_var_param_value) = parameter26_period_name {
3931        local_var_form_params.insert("Parameter26.Name", local_var_param_value.to_string());
3932    }
3933    if let Some(local_var_param_value) = parameter26_period_value {
3934        local_var_form_params.insert("Parameter26.Value", local_var_param_value.to_string());
3935    }
3936    if let Some(local_var_param_value) = parameter27_period_name {
3937        local_var_form_params.insert("Parameter27.Name", local_var_param_value.to_string());
3938    }
3939    if let Some(local_var_param_value) = parameter27_period_value {
3940        local_var_form_params.insert("Parameter27.Value", local_var_param_value.to_string());
3941    }
3942    if let Some(local_var_param_value) = parameter28_period_name {
3943        local_var_form_params.insert("Parameter28.Name", local_var_param_value.to_string());
3944    }
3945    if let Some(local_var_param_value) = parameter28_period_value {
3946        local_var_form_params.insert("Parameter28.Value", local_var_param_value.to_string());
3947    }
3948    if let Some(local_var_param_value) = parameter29_period_name {
3949        local_var_form_params.insert("Parameter29.Name", local_var_param_value.to_string());
3950    }
3951    if let Some(local_var_param_value) = parameter29_period_value {
3952        local_var_form_params.insert("Parameter29.Value", local_var_param_value.to_string());
3953    }
3954    if let Some(local_var_param_value) = parameter30_period_name {
3955        local_var_form_params.insert("Parameter30.Name", local_var_param_value.to_string());
3956    }
3957    if let Some(local_var_param_value) = parameter30_period_value {
3958        local_var_form_params.insert("Parameter30.Value", local_var_param_value.to_string());
3959    }
3960    if let Some(local_var_param_value) = parameter31_period_name {
3961        local_var_form_params.insert("Parameter31.Name", local_var_param_value.to_string());
3962    }
3963    if let Some(local_var_param_value) = parameter31_period_value {
3964        local_var_form_params.insert("Parameter31.Value", local_var_param_value.to_string());
3965    }
3966    if let Some(local_var_param_value) = parameter32_period_name {
3967        local_var_form_params.insert("Parameter32.Name", local_var_param_value.to_string());
3968    }
3969    if let Some(local_var_param_value) = parameter32_period_value {
3970        local_var_form_params.insert("Parameter32.Value", local_var_param_value.to_string());
3971    }
3972    if let Some(local_var_param_value) = parameter33_period_name {
3973        local_var_form_params.insert("Parameter33.Name", local_var_param_value.to_string());
3974    }
3975    if let Some(local_var_param_value) = parameter33_period_value {
3976        local_var_form_params.insert("Parameter33.Value", local_var_param_value.to_string());
3977    }
3978    if let Some(local_var_param_value) = parameter34_period_name {
3979        local_var_form_params.insert("Parameter34.Name", local_var_param_value.to_string());
3980    }
3981    if let Some(local_var_param_value) = parameter34_period_value {
3982        local_var_form_params.insert("Parameter34.Value", local_var_param_value.to_string());
3983    }
3984    if let Some(local_var_param_value) = parameter35_period_name {
3985        local_var_form_params.insert("Parameter35.Name", local_var_param_value.to_string());
3986    }
3987    if let Some(local_var_param_value) = parameter35_period_value {
3988        local_var_form_params.insert("Parameter35.Value", local_var_param_value.to_string());
3989    }
3990    if let Some(local_var_param_value) = parameter36_period_name {
3991        local_var_form_params.insert("Parameter36.Name", local_var_param_value.to_string());
3992    }
3993    if let Some(local_var_param_value) = parameter36_period_value {
3994        local_var_form_params.insert("Parameter36.Value", local_var_param_value.to_string());
3995    }
3996    if let Some(local_var_param_value) = parameter37_period_name {
3997        local_var_form_params.insert("Parameter37.Name", local_var_param_value.to_string());
3998    }
3999    if let Some(local_var_param_value) = parameter37_period_value {
4000        local_var_form_params.insert("Parameter37.Value", local_var_param_value.to_string());
4001    }
4002    if let Some(local_var_param_value) = parameter38_period_name {
4003        local_var_form_params.insert("Parameter38.Name", local_var_param_value.to_string());
4004    }
4005    if let Some(local_var_param_value) = parameter38_period_value {
4006        local_var_form_params.insert("Parameter38.Value", local_var_param_value.to_string());
4007    }
4008    if let Some(local_var_param_value) = parameter39_period_name {
4009        local_var_form_params.insert("Parameter39.Name", local_var_param_value.to_string());
4010    }
4011    if let Some(local_var_param_value) = parameter39_period_value {
4012        local_var_form_params.insert("Parameter39.Value", local_var_param_value.to_string());
4013    }
4014    if let Some(local_var_param_value) = parameter40_period_name {
4015        local_var_form_params.insert("Parameter40.Name", local_var_param_value.to_string());
4016    }
4017    if let Some(local_var_param_value) = parameter40_period_value {
4018        local_var_form_params.insert("Parameter40.Value", local_var_param_value.to_string());
4019    }
4020    if let Some(local_var_param_value) = parameter41_period_name {
4021        local_var_form_params.insert("Parameter41.Name", local_var_param_value.to_string());
4022    }
4023    if let Some(local_var_param_value) = parameter41_period_value {
4024        local_var_form_params.insert("Parameter41.Value", local_var_param_value.to_string());
4025    }
4026    if let Some(local_var_param_value) = parameter42_period_name {
4027        local_var_form_params.insert("Parameter42.Name", local_var_param_value.to_string());
4028    }
4029    if let Some(local_var_param_value) = parameter42_period_value {
4030        local_var_form_params.insert("Parameter42.Value", local_var_param_value.to_string());
4031    }
4032    if let Some(local_var_param_value) = parameter43_period_name {
4033        local_var_form_params.insert("Parameter43.Name", local_var_param_value.to_string());
4034    }
4035    if let Some(local_var_param_value) = parameter43_period_value {
4036        local_var_form_params.insert("Parameter43.Value", local_var_param_value.to_string());
4037    }
4038    if let Some(local_var_param_value) = parameter44_period_name {
4039        local_var_form_params.insert("Parameter44.Name", local_var_param_value.to_string());
4040    }
4041    if let Some(local_var_param_value) = parameter44_period_value {
4042        local_var_form_params.insert("Parameter44.Value", local_var_param_value.to_string());
4043    }
4044    if let Some(local_var_param_value) = parameter45_period_name {
4045        local_var_form_params.insert("Parameter45.Name", local_var_param_value.to_string());
4046    }
4047    if let Some(local_var_param_value) = parameter45_period_value {
4048        local_var_form_params.insert("Parameter45.Value", local_var_param_value.to_string());
4049    }
4050    if let Some(local_var_param_value) = parameter46_period_name {
4051        local_var_form_params.insert("Parameter46.Name", local_var_param_value.to_string());
4052    }
4053    if let Some(local_var_param_value) = parameter46_period_value {
4054        local_var_form_params.insert("Parameter46.Value", local_var_param_value.to_string());
4055    }
4056    if let Some(local_var_param_value) = parameter47_period_name {
4057        local_var_form_params.insert("Parameter47.Name", local_var_param_value.to_string());
4058    }
4059    if let Some(local_var_param_value) = parameter47_period_value {
4060        local_var_form_params.insert("Parameter47.Value", local_var_param_value.to_string());
4061    }
4062    if let Some(local_var_param_value) = parameter48_period_name {
4063        local_var_form_params.insert("Parameter48.Name", local_var_param_value.to_string());
4064    }
4065    if let Some(local_var_param_value) = parameter48_period_value {
4066        local_var_form_params.insert("Parameter48.Value", local_var_param_value.to_string());
4067    }
4068    if let Some(local_var_param_value) = parameter49_period_name {
4069        local_var_form_params.insert("Parameter49.Name", local_var_param_value.to_string());
4070    }
4071    if let Some(local_var_param_value) = parameter49_period_value {
4072        local_var_form_params.insert("Parameter49.Value", local_var_param_value.to_string());
4073    }
4074    if let Some(local_var_param_value) = parameter50_period_name {
4075        local_var_form_params.insert("Parameter50.Name", local_var_param_value.to_string());
4076    }
4077    if let Some(local_var_param_value) = parameter50_period_value {
4078        local_var_form_params.insert("Parameter50.Value", local_var_param_value.to_string());
4079    }
4080    if let Some(local_var_param_value) = parameter51_period_name {
4081        local_var_form_params.insert("Parameter51.Name", local_var_param_value.to_string());
4082    }
4083    if let Some(local_var_param_value) = parameter51_period_value {
4084        local_var_form_params.insert("Parameter51.Value", local_var_param_value.to_string());
4085    }
4086    if let Some(local_var_param_value) = parameter52_period_name {
4087        local_var_form_params.insert("Parameter52.Name", local_var_param_value.to_string());
4088    }
4089    if let Some(local_var_param_value) = parameter52_period_value {
4090        local_var_form_params.insert("Parameter52.Value", local_var_param_value.to_string());
4091    }
4092    if let Some(local_var_param_value) = parameter53_period_name {
4093        local_var_form_params.insert("Parameter53.Name", local_var_param_value.to_string());
4094    }
4095    if let Some(local_var_param_value) = parameter53_period_value {
4096        local_var_form_params.insert("Parameter53.Value", local_var_param_value.to_string());
4097    }
4098    if let Some(local_var_param_value) = parameter54_period_name {
4099        local_var_form_params.insert("Parameter54.Name", local_var_param_value.to_string());
4100    }
4101    if let Some(local_var_param_value) = parameter54_period_value {
4102        local_var_form_params.insert("Parameter54.Value", local_var_param_value.to_string());
4103    }
4104    if let Some(local_var_param_value) = parameter55_period_name {
4105        local_var_form_params.insert("Parameter55.Name", local_var_param_value.to_string());
4106    }
4107    if let Some(local_var_param_value) = parameter55_period_value {
4108        local_var_form_params.insert("Parameter55.Value", local_var_param_value.to_string());
4109    }
4110    if let Some(local_var_param_value) = parameter56_period_name {
4111        local_var_form_params.insert("Parameter56.Name", local_var_param_value.to_string());
4112    }
4113    if let Some(local_var_param_value) = parameter56_period_value {
4114        local_var_form_params.insert("Parameter56.Value", local_var_param_value.to_string());
4115    }
4116    if let Some(local_var_param_value) = parameter57_period_name {
4117        local_var_form_params.insert("Parameter57.Name", local_var_param_value.to_string());
4118    }
4119    if let Some(local_var_param_value) = parameter57_period_value {
4120        local_var_form_params.insert("Parameter57.Value", local_var_param_value.to_string());
4121    }
4122    if let Some(local_var_param_value) = parameter58_period_name {
4123        local_var_form_params.insert("Parameter58.Name", local_var_param_value.to_string());
4124    }
4125    if let Some(local_var_param_value) = parameter58_period_value {
4126        local_var_form_params.insert("Parameter58.Value", local_var_param_value.to_string());
4127    }
4128    if let Some(local_var_param_value) = parameter59_period_name {
4129        local_var_form_params.insert("Parameter59.Name", local_var_param_value.to_string());
4130    }
4131    if let Some(local_var_param_value) = parameter59_period_value {
4132        local_var_form_params.insert("Parameter59.Value", local_var_param_value.to_string());
4133    }
4134    if let Some(local_var_param_value) = parameter60_period_name {
4135        local_var_form_params.insert("Parameter60.Name", local_var_param_value.to_string());
4136    }
4137    if let Some(local_var_param_value) = parameter60_period_value {
4138        local_var_form_params.insert("Parameter60.Value", local_var_param_value.to_string());
4139    }
4140    if let Some(local_var_param_value) = parameter61_period_name {
4141        local_var_form_params.insert("Parameter61.Name", local_var_param_value.to_string());
4142    }
4143    if let Some(local_var_param_value) = parameter61_period_value {
4144        local_var_form_params.insert("Parameter61.Value", local_var_param_value.to_string());
4145    }
4146    if let Some(local_var_param_value) = parameter62_period_name {
4147        local_var_form_params.insert("Parameter62.Name", local_var_param_value.to_string());
4148    }
4149    if let Some(local_var_param_value) = parameter62_period_value {
4150        local_var_form_params.insert("Parameter62.Value", local_var_param_value.to_string());
4151    }
4152    if let Some(local_var_param_value) = parameter63_period_name {
4153        local_var_form_params.insert("Parameter63.Name", local_var_param_value.to_string());
4154    }
4155    if let Some(local_var_param_value) = parameter63_period_value {
4156        local_var_form_params.insert("Parameter63.Value", local_var_param_value.to_string());
4157    }
4158    if let Some(local_var_param_value) = parameter64_period_name {
4159        local_var_form_params.insert("Parameter64.Name", local_var_param_value.to_string());
4160    }
4161    if let Some(local_var_param_value) = parameter64_period_value {
4162        local_var_form_params.insert("Parameter64.Value", local_var_param_value.to_string());
4163    }
4164    if let Some(local_var_param_value) = parameter65_period_name {
4165        local_var_form_params.insert("Parameter65.Name", local_var_param_value.to_string());
4166    }
4167    if let Some(local_var_param_value) = parameter65_period_value {
4168        local_var_form_params.insert("Parameter65.Value", local_var_param_value.to_string());
4169    }
4170    if let Some(local_var_param_value) = parameter66_period_name {
4171        local_var_form_params.insert("Parameter66.Name", local_var_param_value.to_string());
4172    }
4173    if let Some(local_var_param_value) = parameter66_period_value {
4174        local_var_form_params.insert("Parameter66.Value", local_var_param_value.to_string());
4175    }
4176    if let Some(local_var_param_value) = parameter67_period_name {
4177        local_var_form_params.insert("Parameter67.Name", local_var_param_value.to_string());
4178    }
4179    if let Some(local_var_param_value) = parameter67_period_value {
4180        local_var_form_params.insert("Parameter67.Value", local_var_param_value.to_string());
4181    }
4182    if let Some(local_var_param_value) = parameter68_period_name {
4183        local_var_form_params.insert("Parameter68.Name", local_var_param_value.to_string());
4184    }
4185    if let Some(local_var_param_value) = parameter68_period_value {
4186        local_var_form_params.insert("Parameter68.Value", local_var_param_value.to_string());
4187    }
4188    if let Some(local_var_param_value) = parameter69_period_name {
4189        local_var_form_params.insert("Parameter69.Name", local_var_param_value.to_string());
4190    }
4191    if let Some(local_var_param_value) = parameter69_period_value {
4192        local_var_form_params.insert("Parameter69.Value", local_var_param_value.to_string());
4193    }
4194    if let Some(local_var_param_value) = parameter70_period_name {
4195        local_var_form_params.insert("Parameter70.Name", local_var_param_value.to_string());
4196    }
4197    if let Some(local_var_param_value) = parameter70_period_value {
4198        local_var_form_params.insert("Parameter70.Value", local_var_param_value.to_string());
4199    }
4200    if let Some(local_var_param_value) = parameter71_period_name {
4201        local_var_form_params.insert("Parameter71.Name", local_var_param_value.to_string());
4202    }
4203    if let Some(local_var_param_value) = parameter71_period_value {
4204        local_var_form_params.insert("Parameter71.Value", local_var_param_value.to_string());
4205    }
4206    if let Some(local_var_param_value) = parameter72_period_name {
4207        local_var_form_params.insert("Parameter72.Name", local_var_param_value.to_string());
4208    }
4209    if let Some(local_var_param_value) = parameter72_period_value {
4210        local_var_form_params.insert("Parameter72.Value", local_var_param_value.to_string());
4211    }
4212    if let Some(local_var_param_value) = parameter73_period_name {
4213        local_var_form_params.insert("Parameter73.Name", local_var_param_value.to_string());
4214    }
4215    if let Some(local_var_param_value) = parameter73_period_value {
4216        local_var_form_params.insert("Parameter73.Value", local_var_param_value.to_string());
4217    }
4218    if let Some(local_var_param_value) = parameter74_period_name {
4219        local_var_form_params.insert("Parameter74.Name", local_var_param_value.to_string());
4220    }
4221    if let Some(local_var_param_value) = parameter74_period_value {
4222        local_var_form_params.insert("Parameter74.Value", local_var_param_value.to_string());
4223    }
4224    if let Some(local_var_param_value) = parameter75_period_name {
4225        local_var_form_params.insert("Parameter75.Name", local_var_param_value.to_string());
4226    }
4227    if let Some(local_var_param_value) = parameter75_period_value {
4228        local_var_form_params.insert("Parameter75.Value", local_var_param_value.to_string());
4229    }
4230    if let Some(local_var_param_value) = parameter76_period_name {
4231        local_var_form_params.insert("Parameter76.Name", local_var_param_value.to_string());
4232    }
4233    if let Some(local_var_param_value) = parameter76_period_value {
4234        local_var_form_params.insert("Parameter76.Value", local_var_param_value.to_string());
4235    }
4236    if let Some(local_var_param_value) = parameter77_period_name {
4237        local_var_form_params.insert("Parameter77.Name", local_var_param_value.to_string());
4238    }
4239    if let Some(local_var_param_value) = parameter77_period_value {
4240        local_var_form_params.insert("Parameter77.Value", local_var_param_value.to_string());
4241    }
4242    if let Some(local_var_param_value) = parameter78_period_name {
4243        local_var_form_params.insert("Parameter78.Name", local_var_param_value.to_string());
4244    }
4245    if let Some(local_var_param_value) = parameter78_period_value {
4246        local_var_form_params.insert("Parameter78.Value", local_var_param_value.to_string());
4247    }
4248    if let Some(local_var_param_value) = parameter79_period_name {
4249        local_var_form_params.insert("Parameter79.Name", local_var_param_value.to_string());
4250    }
4251    if let Some(local_var_param_value) = parameter79_period_value {
4252        local_var_form_params.insert("Parameter79.Value", local_var_param_value.to_string());
4253    }
4254    if let Some(local_var_param_value) = parameter80_period_name {
4255        local_var_form_params.insert("Parameter80.Name", local_var_param_value.to_string());
4256    }
4257    if let Some(local_var_param_value) = parameter80_period_value {
4258        local_var_form_params.insert("Parameter80.Value", local_var_param_value.to_string());
4259    }
4260    if let Some(local_var_param_value) = parameter81_period_name {
4261        local_var_form_params.insert("Parameter81.Name", local_var_param_value.to_string());
4262    }
4263    if let Some(local_var_param_value) = parameter81_period_value {
4264        local_var_form_params.insert("Parameter81.Value", local_var_param_value.to_string());
4265    }
4266    if let Some(local_var_param_value) = parameter82_period_name {
4267        local_var_form_params.insert("Parameter82.Name", local_var_param_value.to_string());
4268    }
4269    if let Some(local_var_param_value) = parameter82_period_value {
4270        local_var_form_params.insert("Parameter82.Value", local_var_param_value.to_string());
4271    }
4272    if let Some(local_var_param_value) = parameter83_period_name {
4273        local_var_form_params.insert("Parameter83.Name", local_var_param_value.to_string());
4274    }
4275    if let Some(local_var_param_value) = parameter83_period_value {
4276        local_var_form_params.insert("Parameter83.Value", local_var_param_value.to_string());
4277    }
4278    if let Some(local_var_param_value) = parameter84_period_name {
4279        local_var_form_params.insert("Parameter84.Name", local_var_param_value.to_string());
4280    }
4281    if let Some(local_var_param_value) = parameter84_period_value {
4282        local_var_form_params.insert("Parameter84.Value", local_var_param_value.to_string());
4283    }
4284    if let Some(local_var_param_value) = parameter85_period_name {
4285        local_var_form_params.insert("Parameter85.Name", local_var_param_value.to_string());
4286    }
4287    if let Some(local_var_param_value) = parameter85_period_value {
4288        local_var_form_params.insert("Parameter85.Value", local_var_param_value.to_string());
4289    }
4290    if let Some(local_var_param_value) = parameter86_period_name {
4291        local_var_form_params.insert("Parameter86.Name", local_var_param_value.to_string());
4292    }
4293    if let Some(local_var_param_value) = parameter86_period_value {
4294        local_var_form_params.insert("Parameter86.Value", local_var_param_value.to_string());
4295    }
4296    if let Some(local_var_param_value) = parameter87_period_name {
4297        local_var_form_params.insert("Parameter87.Name", local_var_param_value.to_string());
4298    }
4299    if let Some(local_var_param_value) = parameter87_period_value {
4300        local_var_form_params.insert("Parameter87.Value", local_var_param_value.to_string());
4301    }
4302    if let Some(local_var_param_value) = parameter88_period_name {
4303        local_var_form_params.insert("Parameter88.Name", local_var_param_value.to_string());
4304    }
4305    if let Some(local_var_param_value) = parameter88_period_value {
4306        local_var_form_params.insert("Parameter88.Value", local_var_param_value.to_string());
4307    }
4308    if let Some(local_var_param_value) = parameter89_period_name {
4309        local_var_form_params.insert("Parameter89.Name", local_var_param_value.to_string());
4310    }
4311    if let Some(local_var_param_value) = parameter89_period_value {
4312        local_var_form_params.insert("Parameter89.Value", local_var_param_value.to_string());
4313    }
4314    if let Some(local_var_param_value) = parameter90_period_name {
4315        local_var_form_params.insert("Parameter90.Name", local_var_param_value.to_string());
4316    }
4317    if let Some(local_var_param_value) = parameter90_period_value {
4318        local_var_form_params.insert("Parameter90.Value", local_var_param_value.to_string());
4319    }
4320    if let Some(local_var_param_value) = parameter91_period_name {
4321        local_var_form_params.insert("Parameter91.Name", local_var_param_value.to_string());
4322    }
4323    if let Some(local_var_param_value) = parameter91_period_value {
4324        local_var_form_params.insert("Parameter91.Value", local_var_param_value.to_string());
4325    }
4326    if let Some(local_var_param_value) = parameter92_period_name {
4327        local_var_form_params.insert("Parameter92.Name", local_var_param_value.to_string());
4328    }
4329    if let Some(local_var_param_value) = parameter92_period_value {
4330        local_var_form_params.insert("Parameter92.Value", local_var_param_value.to_string());
4331    }
4332    if let Some(local_var_param_value) = parameter93_period_name {
4333        local_var_form_params.insert("Parameter93.Name", local_var_param_value.to_string());
4334    }
4335    if let Some(local_var_param_value) = parameter93_period_value {
4336        local_var_form_params.insert("Parameter93.Value", local_var_param_value.to_string());
4337    }
4338    if let Some(local_var_param_value) = parameter94_period_name {
4339        local_var_form_params.insert("Parameter94.Name", local_var_param_value.to_string());
4340    }
4341    if let Some(local_var_param_value) = parameter94_period_value {
4342        local_var_form_params.insert("Parameter94.Value", local_var_param_value.to_string());
4343    }
4344    if let Some(local_var_param_value) = parameter95_period_name {
4345        local_var_form_params.insert("Parameter95.Name", local_var_param_value.to_string());
4346    }
4347    if let Some(local_var_param_value) = parameter95_period_value {
4348        local_var_form_params.insert("Parameter95.Value", local_var_param_value.to_string());
4349    }
4350    if let Some(local_var_param_value) = parameter96_period_name {
4351        local_var_form_params.insert("Parameter96.Name", local_var_param_value.to_string());
4352    }
4353    if let Some(local_var_param_value) = parameter96_period_value {
4354        local_var_form_params.insert("Parameter96.Value", local_var_param_value.to_string());
4355    }
4356    if let Some(local_var_param_value) = parameter97_period_name {
4357        local_var_form_params.insert("Parameter97.Name", local_var_param_value.to_string());
4358    }
4359    if let Some(local_var_param_value) = parameter97_period_value {
4360        local_var_form_params.insert("Parameter97.Value", local_var_param_value.to_string());
4361    }
4362    if let Some(local_var_param_value) = parameter98_period_name {
4363        local_var_form_params.insert("Parameter98.Name", local_var_param_value.to_string());
4364    }
4365    if let Some(local_var_param_value) = parameter98_period_value {
4366        local_var_form_params.insert("Parameter98.Value", local_var_param_value.to_string());
4367    }
4368    if let Some(local_var_param_value) = parameter99_period_name {
4369        local_var_form_params.insert("Parameter99.Name", local_var_param_value.to_string());
4370    }
4371    if let Some(local_var_param_value) = parameter99_period_value {
4372        local_var_form_params.insert("Parameter99.Value", local_var_param_value.to_string());
4373    }
4374    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
4375
4376    let local_var_req = local_var_req_builder.build()?;
4377    let local_var_resp = local_var_client.execute(local_var_req).await?;
4378
4379    let local_var_status = local_var_resp.status();
4380    let local_var_content = local_var_resp.text().await?;
4381
4382    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4383        serde_json::from_str(&local_var_content).map_err(Error::from)
4384    } else {
4385        let local_var_entity: Option<CreateStreamError> = serde_json::from_str(&local_var_content).ok();
4386        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4387        Err(Error::ResponseError(local_var_error))
4388    }
4389}
4390
4391/// Create a new token for ICE servers
4392pub async fn create_token(configuration: &configuration::Configuration, account_sid: &str, ttl: Option<i32>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodToken, Error<CreateTokenError>> {
4393    let local_var_configuration = configuration;
4394
4395    let local_var_client = &local_var_configuration.client;
4396
4397    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Tokens.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
4398    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4399
4400    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4401        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4402    }
4403    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4404        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4405    };
4406    let mut local_var_form_params = std::collections::HashMap::new();
4407    if let Some(local_var_param_value) = ttl {
4408        local_var_form_params.insert("Ttl", local_var_param_value.to_string());
4409    }
4410    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
4411
4412    let local_var_req = local_var_req_builder.build()?;
4413    let local_var_resp = local_var_client.execute(local_var_req).await?;
4414
4415    let local_var_status = local_var_resp.status();
4416    let local_var_content = local_var_resp.text().await?;
4417
4418    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4419        serde_json::from_str(&local_var_content).map_err(Error::from)
4420    } else {
4421        let local_var_entity: Option<CreateTokenError> = serde_json::from_str(&local_var_content).ok();
4422        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4423        Err(Error::ResponseError(local_var_error))
4424    }
4425}
4426
4427/// Create a new UsageTrigger
4428pub async fn create_usage_trigger(configuration: &configuration::Configuration, account_sid: &str, callback_url: &str, trigger_value: &str, usage_category: &str, callback_method: Option<&str>, friendly_name: Option<&str>, recurring: Option<&str>, trigger_by: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodUsagePeriodUsageTrigger, Error<CreateUsageTriggerError>> {
4429    let local_var_configuration = configuration;
4430
4431    let local_var_client = &local_var_configuration.client;
4432
4433    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Triggers.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
4434    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4435
4436    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4437        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4438    }
4439    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4440        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4441    };
4442    let mut local_var_form_params = std::collections::HashMap::new();
4443    local_var_form_params.insert("CallbackUrl", callback_url.to_string());
4444    local_var_form_params.insert("TriggerValue", trigger_value.to_string());
4445    local_var_form_params.insert("UsageCategory", usage_category.to_string());
4446    if let Some(local_var_param_value) = callback_method {
4447        local_var_form_params.insert("CallbackMethod", local_var_param_value.to_string());
4448    }
4449    if let Some(local_var_param_value) = friendly_name {
4450        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
4451    }
4452    if let Some(local_var_param_value) = recurring {
4453        local_var_form_params.insert("Recurring", local_var_param_value.to_string());
4454    }
4455    if let Some(local_var_param_value) = trigger_by {
4456        local_var_form_params.insert("TriggerBy", local_var_param_value.to_string());
4457    }
4458    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
4459
4460    let local_var_req = local_var_req_builder.build()?;
4461    let local_var_resp = local_var_client.execute(local_var_req).await?;
4462
4463    let local_var_status = local_var_resp.status();
4464    let local_var_content = local_var_resp.text().await?;
4465
4466    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4467        serde_json::from_str(&local_var_content).map_err(Error::from)
4468    } else {
4469        let local_var_entity: Option<CreateUsageTriggerError> = serde_json::from_str(&local_var_content).ok();
4470        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4471        Err(Error::ResponseError(local_var_error))
4472    }
4473}
4474
4475/// Create a new User Defined Message for the given Call SID.
4476pub async fn create_user_defined_message(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, content: &str, idempotency_key: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodUserDefinedMessage, Error<CreateUserDefinedMessageError>> {
4477    let local_var_configuration = configuration;
4478
4479    let local_var_client = &local_var_configuration.client;
4480
4481    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/UserDefinedMessages.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
4482    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4483
4484    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4485        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4486    }
4487    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4488        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4489    };
4490    let mut local_var_form_params = std::collections::HashMap::new();
4491    local_var_form_params.insert("Content", content.to_string());
4492    if let Some(local_var_param_value) = idempotency_key {
4493        local_var_form_params.insert("IdempotencyKey", local_var_param_value.to_string());
4494    }
4495    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
4496
4497    let local_var_req = local_var_req_builder.build()?;
4498    let local_var_resp = local_var_client.execute(local_var_req).await?;
4499
4500    let local_var_status = local_var_resp.status();
4501    let local_var_content = local_var_resp.text().await?;
4502
4503    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4504        serde_json::from_str(&local_var_content).map_err(Error::from)
4505    } else {
4506        let local_var_entity: Option<CreateUserDefinedMessageError> = serde_json::from_str(&local_var_content).ok();
4507        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4508        Err(Error::ResponseError(local_var_error))
4509    }
4510}
4511
4512/// Subscribe to User Defined Messages for a given Call SID.
4513pub async fn create_user_defined_message_subscription(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, callback: &str, method: &str, idempotency_key: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodUserDefinedMessageSubscription, Error<CreateUserDefinedMessageSubscriptionError>> {
4514    let local_var_configuration = configuration;
4515
4516    let local_var_client = &local_var_configuration.client;
4517
4518    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/UserDefinedMessageSubscriptions.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
4519    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4520
4521    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4522        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4523    }
4524    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4525        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4526    };
4527    let mut local_var_form_params = std::collections::HashMap::new();
4528    local_var_form_params.insert("Callback", callback.to_string());
4529    local_var_form_params.insert("Method", method.to_string());
4530    if let Some(local_var_param_value) = idempotency_key {
4531        local_var_form_params.insert("IdempotencyKey", local_var_param_value.to_string());
4532    }
4533    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
4534
4535    let local_var_req = local_var_req_builder.build()?;
4536    let local_var_resp = local_var_client.execute(local_var_req).await?;
4537
4538    let local_var_status = local_var_resp.status();
4539    let local_var_content = local_var_resp.text().await?;
4540
4541    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4542        serde_json::from_str(&local_var_content).map_err(Error::from)
4543    } else {
4544        let local_var_entity: Option<CreateUserDefinedMessageSubscriptionError> = serde_json::from_str(&local_var_content).ok();
4545        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4546        Err(Error::ResponseError(local_var_error))
4547    }
4548}
4549
4550/// 
4551pub async fn create_validation_request(configuration: &configuration::Configuration, account_sid: &str, phone_number: &str, friendly_name: Option<&str>, call_delay: Option<i32>, extension: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodValidationRequest, Error<CreateValidationRequestError>> {
4552    let local_var_configuration = configuration;
4553
4554    let local_var_client = &local_var_configuration.client;
4555
4556    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/OutgoingCallerIds.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
4557    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
4558
4559    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4560        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4561    }
4562    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4563        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4564    };
4565    let mut local_var_form_params = std::collections::HashMap::new();
4566    local_var_form_params.insert("PhoneNumber", phone_number.to_string());
4567    if let Some(local_var_param_value) = friendly_name {
4568        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
4569    }
4570    if let Some(local_var_param_value) = call_delay {
4571        local_var_form_params.insert("CallDelay", local_var_param_value.to_string());
4572    }
4573    if let Some(local_var_param_value) = extension {
4574        local_var_form_params.insert("Extension", local_var_param_value.to_string());
4575    }
4576    if let Some(local_var_param_value) = status_callback {
4577        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
4578    }
4579    if let Some(local_var_param_value) = status_callback_method {
4580        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
4581    }
4582    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
4583
4584    let local_var_req = local_var_req_builder.build()?;
4585    let local_var_resp = local_var_client.execute(local_var_req).await?;
4586
4587    let local_var_status = local_var_resp.status();
4588    let local_var_content = local_var_resp.text().await?;
4589
4590    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4591        serde_json::from_str(&local_var_content).map_err(Error::from)
4592    } else {
4593        let local_var_entity: Option<CreateValidationRequestError> = serde_json::from_str(&local_var_content).ok();
4594        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4595        Err(Error::ResponseError(local_var_error))
4596    }
4597}
4598
4599/// 
4600pub async fn delete_address(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteAddressError>> {
4601    let local_var_configuration = configuration;
4602
4603    let local_var_client = &local_var_configuration.client;
4604
4605    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Addresses/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
4606    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4607
4608    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4609        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4610    }
4611    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4612        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4613    };
4614
4615    let local_var_req = local_var_req_builder.build()?;
4616    let local_var_resp = local_var_client.execute(local_var_req).await?;
4617
4618    let local_var_status = local_var_resp.status();
4619    let local_var_content = local_var_resp.text().await?;
4620
4621    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4622        Ok(())
4623    } else {
4624        let local_var_entity: Option<DeleteAddressError> = serde_json::from_str(&local_var_content).ok();
4625        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4626        Err(Error::ResponseError(local_var_error))
4627    }
4628}
4629
4630/// Delete the application by the specified application sid
4631pub async fn delete_application(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteApplicationError>> {
4632    let local_var_configuration = configuration;
4633
4634    let local_var_client = &local_var_configuration.client;
4635
4636    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
4637    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4638
4639    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4640        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4641    }
4642    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4643        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4644    };
4645
4646    let local_var_req = local_var_req_builder.build()?;
4647    let local_var_resp = local_var_client.execute(local_var_req).await?;
4648
4649    let local_var_status = local_var_resp.status();
4650    let local_var_content = local_var_resp.text().await?;
4651
4652    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4653        Ok(())
4654    } else {
4655        let local_var_entity: Option<DeleteApplicationError> = serde_json::from_str(&local_var_content).ok();
4656        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4657        Err(Error::ResponseError(local_var_error))
4658    }
4659}
4660
4661/// Delete a Call record from your account. Once the record is deleted, it will no longer appear in the API and Account Portal logs.
4662pub async fn delete_call(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteCallError>> {
4663    let local_var_configuration = configuration;
4664
4665    let local_var_client = &local_var_configuration.client;
4666
4667    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
4668    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4669
4670    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4671        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4672    }
4673    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4674        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4675    };
4676
4677    let local_var_req = local_var_req_builder.build()?;
4678    let local_var_resp = local_var_client.execute(local_var_req).await?;
4679
4680    let local_var_status = local_var_resp.status();
4681    let local_var_content = local_var_resp.text().await?;
4682
4683    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4684        Ok(())
4685    } else {
4686        let local_var_entity: Option<DeleteCallError> = serde_json::from_str(&local_var_content).ok();
4687        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4688        Err(Error::ResponseError(local_var_error))
4689    }
4690}
4691
4692/// Delete a FeedbackSummary resource from a call
4693pub async fn delete_call_feedback_summary(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteCallFeedbackSummaryError>> {
4694    let local_var_configuration = configuration;
4695
4696    let local_var_client = &local_var_configuration.client;
4697
4698    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/FeedbackSummary/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
4699    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4700
4701    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4702        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4703    }
4704    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4705        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4706    };
4707
4708    let local_var_req = local_var_req_builder.build()?;
4709    let local_var_resp = local_var_client.execute(local_var_req).await?;
4710
4711    let local_var_status = local_var_resp.status();
4712    let local_var_content = local_var_resp.text().await?;
4713
4714    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4715        Ok(())
4716    } else {
4717        let local_var_entity: Option<DeleteCallFeedbackSummaryError> = serde_json::from_str(&local_var_content).ok();
4718        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4719        Err(Error::ResponseError(local_var_error))
4720    }
4721}
4722
4723/// Delete a recording from your account
4724pub async fn delete_call_recording(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, sid: &str) -> Result<(), Error<DeleteCallRecordingError>> {
4725    let local_var_configuration = configuration;
4726
4727    let local_var_client = &local_var_configuration.client;
4728
4729    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Recordings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid), Sid=crate::apis::urlencode(sid));
4730    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4731
4732    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4733        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4734    }
4735    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4736        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4737    };
4738
4739    let local_var_req = local_var_req_builder.build()?;
4740    let local_var_resp = local_var_client.execute(local_var_req).await?;
4741
4742    let local_var_status = local_var_resp.status();
4743    let local_var_content = local_var_resp.text().await?;
4744
4745    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4746        Ok(())
4747    } else {
4748        let local_var_entity: Option<DeleteCallRecordingError> = serde_json::from_str(&local_var_content).ok();
4749        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4750        Err(Error::ResponseError(local_var_error))
4751    }
4752}
4753
4754/// Delete a recording from your account
4755pub async fn delete_conference_recording(configuration: &configuration::Configuration, account_sid: &str, conference_sid: &str, sid: &str) -> Result<(), Error<DeleteConferenceRecordingError>> {
4756    let local_var_configuration = configuration;
4757
4758    let local_var_client = &local_var_configuration.client;
4759
4760    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{ConferenceSid}/Recordings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConferenceSid=crate::apis::urlencode(conference_sid), Sid=crate::apis::urlencode(sid));
4761    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4762
4763    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4764        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4765    }
4766    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4767        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4768    };
4769
4770    let local_var_req = local_var_req_builder.build()?;
4771    let local_var_resp = local_var_client.execute(local_var_req).await?;
4772
4773    let local_var_status = local_var_resp.status();
4774    let local_var_content = local_var_resp.text().await?;
4775
4776    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4777        Ok(())
4778    } else {
4779        let local_var_entity: Option<DeleteConferenceRecordingError> = serde_json::from_str(&local_var_content).ok();
4780        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4781        Err(Error::ResponseError(local_var_error))
4782    }
4783}
4784
4785/// Delete an instance of a connect-app
4786pub async fn delete_connect_app(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteConnectAppError>> {
4787    let local_var_configuration = configuration;
4788
4789    let local_var_client = &local_var_configuration.client;
4790
4791    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/ConnectApps/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
4792    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4793
4794    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4795        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4796    }
4797    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4798        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4799    };
4800
4801    let local_var_req = local_var_req_builder.build()?;
4802    let local_var_resp = local_var_client.execute(local_var_req).await?;
4803
4804    let local_var_status = local_var_resp.status();
4805    let local_var_content = local_var_resp.text().await?;
4806
4807    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4808        Ok(())
4809    } else {
4810        let local_var_entity: Option<DeleteConnectAppError> = serde_json::from_str(&local_var_content).ok();
4811        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4812        Err(Error::ResponseError(local_var_error))
4813    }
4814}
4815
4816/// Delete a phone-numbers belonging to the account used to make the request.
4817pub async fn delete_incoming_phone_number(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteIncomingPhoneNumberError>> {
4818    let local_var_configuration = configuration;
4819
4820    let local_var_client = &local_var_configuration.client;
4821
4822    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
4823    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4824
4825    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4826        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4827    }
4828    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4829        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4830    };
4831
4832    let local_var_req = local_var_req_builder.build()?;
4833    let local_var_resp = local_var_client.execute(local_var_req).await?;
4834
4835    let local_var_status = local_var_resp.status();
4836    let local_var_content = local_var_resp.text().await?;
4837
4838    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4839        Ok(())
4840    } else {
4841        let local_var_entity: Option<DeleteIncomingPhoneNumberError> = serde_json::from_str(&local_var_content).ok();
4842        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4843        Err(Error::ResponseError(local_var_error))
4844    }
4845}
4846
4847/// Remove the assignment of an Add-on installation from the Number specified.
4848pub async fn delete_incoming_phone_number_assigned_add_on(configuration: &configuration::Configuration, account_sid: &str, resource_sid: &str, sid: &str) -> Result<(), Error<DeleteIncomingPhoneNumberAssignedAddOnError>> {
4849    let local_var_configuration = configuration;
4850
4851    let local_var_client = &local_var_configuration.client;
4852
4853    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/{ResourceSid}/AssignedAddOns/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ResourceSid=crate::apis::urlencode(resource_sid), Sid=crate::apis::urlencode(sid));
4854    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4855
4856    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4857        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4858    }
4859    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4860        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4861    };
4862
4863    let local_var_req = local_var_req_builder.build()?;
4864    let local_var_resp = local_var_client.execute(local_var_req).await?;
4865
4866    let local_var_status = local_var_resp.status();
4867    let local_var_content = local_var_resp.text().await?;
4868
4869    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4870        Ok(())
4871    } else {
4872        let local_var_entity: Option<DeleteIncomingPhoneNumberAssignedAddOnError> = serde_json::from_str(&local_var_content).ok();
4873        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4874        Err(Error::ResponseError(local_var_error))
4875    }
4876}
4877
4878/// 
4879pub async fn delete_key(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteKeyError>> {
4880    let local_var_configuration = configuration;
4881
4882    let local_var_client = &local_var_configuration.client;
4883
4884    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Keys/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
4885    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4886
4887    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4888        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4889    }
4890    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4891        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4892    };
4893
4894    let local_var_req = local_var_req_builder.build()?;
4895    let local_var_resp = local_var_client.execute(local_var_req).await?;
4896
4897    let local_var_status = local_var_resp.status();
4898    let local_var_content = local_var_resp.text().await?;
4899
4900    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4901        Ok(())
4902    } else {
4903        let local_var_entity: Option<DeleteKeyError> = serde_json::from_str(&local_var_content).ok();
4904        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4905        Err(Error::ResponseError(local_var_error))
4906    }
4907}
4908
4909/// Delete media from your account. Once delete, you will no longer be billed
4910pub async fn delete_media(configuration: &configuration::Configuration, account_sid: &str, message_sid: &str, sid: &str) -> Result<(), Error<DeleteMediaError>> {
4911    let local_var_configuration = configuration;
4912
4913    let local_var_client = &local_var_configuration.client;
4914
4915    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{MessageSid}/Media/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), MessageSid=crate::apis::urlencode(message_sid), Sid=crate::apis::urlencode(sid));
4916    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4917
4918    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4919        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4920    }
4921    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4922        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4923    };
4924
4925    let local_var_req = local_var_req_builder.build()?;
4926    let local_var_resp = local_var_client.execute(local_var_req).await?;
4927
4928    let local_var_status = local_var_resp.status();
4929    let local_var_content = local_var_resp.text().await?;
4930
4931    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4932        Ok(())
4933    } else {
4934        let local_var_entity: Option<DeleteMediaError> = serde_json::from_str(&local_var_content).ok();
4935        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4936        Err(Error::ResponseError(local_var_error))
4937    }
4938}
4939
4940/// Deletes a message record from your account
4941pub async fn delete_message(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteMessageError>> {
4942    let local_var_configuration = configuration;
4943
4944    let local_var_client = &local_var_configuration.client;
4945
4946    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
4947    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4948
4949    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4950        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4951    }
4952    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4953        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4954    };
4955
4956    let local_var_req = local_var_req_builder.build()?;
4957    let local_var_resp = local_var_client.execute(local_var_req).await?;
4958
4959    let local_var_status = local_var_resp.status();
4960    let local_var_content = local_var_resp.text().await?;
4961
4962    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4963        Ok(())
4964    } else {
4965        let local_var_entity: Option<DeleteMessageError> = serde_json::from_str(&local_var_content).ok();
4966        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4967        Err(Error::ResponseError(local_var_error))
4968    }
4969}
4970
4971/// Delete the caller-id specified from the account
4972pub async fn delete_outgoing_caller_id(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteOutgoingCallerIdError>> {
4973    let local_var_configuration = configuration;
4974
4975    let local_var_client = &local_var_configuration.client;
4976
4977    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/OutgoingCallerIds/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
4978    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
4979
4980    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
4981        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
4982    }
4983    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
4984        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
4985    };
4986
4987    let local_var_req = local_var_req_builder.build()?;
4988    let local_var_resp = local_var_client.execute(local_var_req).await?;
4989
4990    let local_var_status = local_var_resp.status();
4991    let local_var_content = local_var_resp.text().await?;
4992
4993    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
4994        Ok(())
4995    } else {
4996        let local_var_entity: Option<DeleteOutgoingCallerIdError> = serde_json::from_str(&local_var_content).ok();
4997        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
4998        Err(Error::ResponseError(local_var_error))
4999    }
5000}
5001
5002/// Kick a participant from a given conference
5003pub async fn delete_participant(configuration: &configuration::Configuration, account_sid: &str, conference_sid: &str, call_sid: &str) -> Result<(), Error<DeleteParticipantError>> {
5004    let local_var_configuration = configuration;
5005
5006    let local_var_client = &local_var_configuration.client;
5007
5008    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{ConferenceSid}/Participants/{CallSid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConferenceSid=crate::apis::urlencode(conference_sid), CallSid=crate::apis::urlencode(call_sid));
5009    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5010
5011    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5012        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5013    }
5014    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5015        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5016    };
5017
5018    let local_var_req = local_var_req_builder.build()?;
5019    let local_var_resp = local_var_client.execute(local_var_req).await?;
5020
5021    let local_var_status = local_var_resp.status();
5022    let local_var_content = local_var_resp.text().await?;
5023
5024    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5025        Ok(())
5026    } else {
5027        let local_var_entity: Option<DeleteParticipantError> = serde_json::from_str(&local_var_content).ok();
5028        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5029        Err(Error::ResponseError(local_var_error))
5030    }
5031}
5032
5033/// Remove an empty queue
5034pub async fn delete_queue(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteQueueError>> {
5035    let local_var_configuration = configuration;
5036
5037    let local_var_client = &local_var_configuration.client;
5038
5039    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Queues/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5040    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5041
5042    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5043        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5044    }
5045    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5046        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5047    };
5048
5049    let local_var_req = local_var_req_builder.build()?;
5050    let local_var_resp = local_var_client.execute(local_var_req).await?;
5051
5052    let local_var_status = local_var_resp.status();
5053    let local_var_content = local_var_resp.text().await?;
5054
5055    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5056        Ok(())
5057    } else {
5058        let local_var_entity: Option<DeleteQueueError> = serde_json::from_str(&local_var_content).ok();
5059        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5060        Err(Error::ResponseError(local_var_error))
5061    }
5062}
5063
5064/// Delete a recording from your account
5065pub async fn delete_recording(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteRecordingError>> {
5066    let local_var_configuration = configuration;
5067
5068    let local_var_client = &local_var_configuration.client;
5069
5070    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5071    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5072
5073    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5074        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5075    }
5076    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5077        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5078    };
5079
5080    let local_var_req = local_var_req_builder.build()?;
5081    let local_var_resp = local_var_client.execute(local_var_req).await?;
5082
5083    let local_var_status = local_var_resp.status();
5084    let local_var_content = local_var_resp.text().await?;
5085
5086    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5087        Ok(())
5088    } else {
5089        let local_var_entity: Option<DeleteRecordingError> = serde_json::from_str(&local_var_content).ok();
5090        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5091        Err(Error::ResponseError(local_var_error))
5092    }
5093}
5094
5095/// Delete a result and purge all associated Payloads
5096pub async fn delete_recording_add_on_result(configuration: &configuration::Configuration, account_sid: &str, reference_sid: &str, sid: &str) -> Result<(), Error<DeleteRecordingAddOnResultError>> {
5097    let local_var_configuration = configuration;
5098
5099    let local_var_client = &local_var_configuration.client;
5100
5101    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{ReferenceSid}/AddOnResults/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ReferenceSid=crate::apis::urlencode(reference_sid), Sid=crate::apis::urlencode(sid));
5102    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5103
5104    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5105        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5106    }
5107    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5108        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5109    };
5110
5111    let local_var_req = local_var_req_builder.build()?;
5112    let local_var_resp = local_var_client.execute(local_var_req).await?;
5113
5114    let local_var_status = local_var_resp.status();
5115    let local_var_content = local_var_resp.text().await?;
5116
5117    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5118        Ok(())
5119    } else {
5120        let local_var_entity: Option<DeleteRecordingAddOnResultError> = serde_json::from_str(&local_var_content).ok();
5121        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5122        Err(Error::ResponseError(local_var_error))
5123    }
5124}
5125
5126/// Delete a payload from the result along with all associated Data
5127pub async fn delete_recording_add_on_result_payload(configuration: &configuration::Configuration, account_sid: &str, reference_sid: &str, add_on_result_sid: &str, sid: &str) -> Result<(), Error<DeleteRecordingAddOnResultPayloadError>> {
5128    let local_var_configuration = configuration;
5129
5130    let local_var_client = &local_var_configuration.client;
5131
5132    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{ReferenceSid}/AddOnResults/{AddOnResultSid}/Payloads/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ReferenceSid=crate::apis::urlencode(reference_sid), AddOnResultSid=crate::apis::urlencode(add_on_result_sid), Sid=crate::apis::urlencode(sid));
5133    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5134
5135    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5136        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5137    }
5138    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5139        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5140    };
5141
5142    let local_var_req = local_var_req_builder.build()?;
5143    let local_var_resp = local_var_client.execute(local_var_req).await?;
5144
5145    let local_var_status = local_var_resp.status();
5146    let local_var_content = local_var_resp.text().await?;
5147
5148    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5149        Ok(())
5150    } else {
5151        let local_var_entity: Option<DeleteRecordingAddOnResultPayloadError> = serde_json::from_str(&local_var_content).ok();
5152        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5153        Err(Error::ResponseError(local_var_error))
5154    }
5155}
5156
5157/// 
5158pub async fn delete_recording_transcription(configuration: &configuration::Configuration, account_sid: &str, recording_sid: &str, sid: &str) -> Result<(), Error<DeleteRecordingTranscriptionError>> {
5159    let local_var_configuration = configuration;
5160
5161    let local_var_client = &local_var_configuration.client;
5162
5163    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{RecordingSid}/Transcriptions/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), RecordingSid=crate::apis::urlencode(recording_sid), Sid=crate::apis::urlencode(sid));
5164    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5165
5166    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5167        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5168    }
5169    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5170        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5171    };
5172
5173    let local_var_req = local_var_req_builder.build()?;
5174    let local_var_resp = local_var_client.execute(local_var_req).await?;
5175
5176    let local_var_status = local_var_resp.status();
5177    let local_var_content = local_var_resp.text().await?;
5178
5179    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5180        Ok(())
5181    } else {
5182        let local_var_entity: Option<DeleteRecordingTranscriptionError> = serde_json::from_str(&local_var_content).ok();
5183        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5184        Err(Error::ResponseError(local_var_error))
5185    }
5186}
5187
5188/// 
5189pub async fn delete_signing_key(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteSigningKeyError>> {
5190    let local_var_configuration = configuration;
5191
5192    let local_var_client = &local_var_configuration.client;
5193
5194    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SigningKeys/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5195    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5196
5197    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5198        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5199    }
5200    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5201        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5202    };
5203
5204    let local_var_req = local_var_req_builder.build()?;
5205    let local_var_resp = local_var_client.execute(local_var_req).await?;
5206
5207    let local_var_status = local_var_resp.status();
5208    let local_var_content = local_var_resp.text().await?;
5209
5210    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5211        Ok(())
5212    } else {
5213        let local_var_entity: Option<DeleteSigningKeyError> = serde_json::from_str(&local_var_content).ok();
5214        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5215        Err(Error::ResponseError(local_var_error))
5216    }
5217}
5218
5219/// Delete a credential list mapping from the requested domain
5220pub async fn delete_sip_auth_calls_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<(), Error<DeleteSipAuthCallsCredentialListMappingError>> {
5221    let local_var_configuration = configuration;
5222
5223    let local_var_client = &local_var_configuration.client;
5224
5225    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/CredentialListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
5226    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5227
5228    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5229        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5230    }
5231    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5232        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5233    };
5234
5235    let local_var_req = local_var_req_builder.build()?;
5236    let local_var_resp = local_var_client.execute(local_var_req).await?;
5237
5238    let local_var_status = local_var_resp.status();
5239    let local_var_content = local_var_resp.text().await?;
5240
5241    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5242        Ok(())
5243    } else {
5244        let local_var_entity: Option<DeleteSipAuthCallsCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
5245        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5246        Err(Error::ResponseError(local_var_error))
5247    }
5248}
5249
5250/// Delete an IP Access Control List mapping from the requested domain
5251pub async fn delete_sip_auth_calls_ip_access_control_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<(), Error<DeleteSipAuthCallsIpAccessControlListMappingError>> {
5252    let local_var_configuration = configuration;
5253
5254    let local_var_client = &local_var_configuration.client;
5255
5256    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/IpAccessControlListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
5257    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5258
5259    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5260        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5261    }
5262    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5263        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5264    };
5265
5266    let local_var_req = local_var_req_builder.build()?;
5267    let local_var_resp = local_var_client.execute(local_var_req).await?;
5268
5269    let local_var_status = local_var_resp.status();
5270    let local_var_content = local_var_resp.text().await?;
5271
5272    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5273        Ok(())
5274    } else {
5275        let local_var_entity: Option<DeleteSipAuthCallsIpAccessControlListMappingError> = serde_json::from_str(&local_var_content).ok();
5276        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5277        Err(Error::ResponseError(local_var_error))
5278    }
5279}
5280
5281/// Delete a credential list mapping from the requested domain
5282pub async fn delete_sip_auth_registrations_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<(), Error<DeleteSipAuthRegistrationsCredentialListMappingError>> {
5283    let local_var_configuration = configuration;
5284
5285    let local_var_client = &local_var_configuration.client;
5286
5287    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Registrations/CredentialListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
5288    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5289
5290    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5291        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5292    }
5293    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5294        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5295    };
5296
5297    let local_var_req = local_var_req_builder.build()?;
5298    let local_var_resp = local_var_client.execute(local_var_req).await?;
5299
5300    let local_var_status = local_var_resp.status();
5301    let local_var_content = local_var_resp.text().await?;
5302
5303    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5304        Ok(())
5305    } else {
5306        let local_var_entity: Option<DeleteSipAuthRegistrationsCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
5307        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5308        Err(Error::ResponseError(local_var_error))
5309    }
5310}
5311
5312/// Delete a credential resource.
5313pub async fn delete_sip_credential(configuration: &configuration::Configuration, account_sid: &str, credential_list_sid: &str, sid: &str) -> Result<(), Error<DeleteSipCredentialError>> {
5314    let local_var_configuration = configuration;
5315
5316    let local_var_client = &local_var_configuration.client;
5317
5318    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists/{CredentialListSid}/Credentials/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CredentialListSid=crate::apis::urlencode(credential_list_sid), Sid=crate::apis::urlencode(sid));
5319    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5320
5321    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5322        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5323    }
5324    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5325        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5326    };
5327
5328    let local_var_req = local_var_req_builder.build()?;
5329    let local_var_resp = local_var_client.execute(local_var_req).await?;
5330
5331    let local_var_status = local_var_resp.status();
5332    let local_var_content = local_var_resp.text().await?;
5333
5334    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5335        Ok(())
5336    } else {
5337        let local_var_entity: Option<DeleteSipCredentialError> = serde_json::from_str(&local_var_content).ok();
5338        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5339        Err(Error::ResponseError(local_var_error))
5340    }
5341}
5342
5343/// Delete a Credential List
5344pub async fn delete_sip_credential_list(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteSipCredentialListError>> {
5345    let local_var_configuration = configuration;
5346
5347    let local_var_client = &local_var_configuration.client;
5348
5349    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5350    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5351
5352    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5353        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5354    }
5355    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5356        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5357    };
5358
5359    let local_var_req = local_var_req_builder.build()?;
5360    let local_var_resp = local_var_client.execute(local_var_req).await?;
5361
5362    let local_var_status = local_var_resp.status();
5363    let local_var_content = local_var_resp.text().await?;
5364
5365    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5366        Ok(())
5367    } else {
5368        let local_var_entity: Option<DeleteSipCredentialListError> = serde_json::from_str(&local_var_content).ok();
5369        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5370        Err(Error::ResponseError(local_var_error))
5371    }
5372}
5373
5374/// Delete a CredentialListMapping resource from an account.
5375pub async fn delete_sip_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<(), Error<DeleteSipCredentialListMappingError>> {
5376    let local_var_configuration = configuration;
5377
5378    let local_var_client = &local_var_configuration.client;
5379
5380    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/CredentialListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
5381    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5382
5383    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5384        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5385    }
5386    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5387        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5388    };
5389
5390    let local_var_req = local_var_req_builder.build()?;
5391    let local_var_resp = local_var_client.execute(local_var_req).await?;
5392
5393    let local_var_status = local_var_resp.status();
5394    let local_var_content = local_var_resp.text().await?;
5395
5396    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5397        Ok(())
5398    } else {
5399        let local_var_entity: Option<DeleteSipCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
5400        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5401        Err(Error::ResponseError(local_var_error))
5402    }
5403}
5404
5405/// Delete an instance of a Domain
5406pub async fn delete_sip_domain(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteSipDomainError>> {
5407    let local_var_configuration = configuration;
5408
5409    let local_var_client = &local_var_configuration.client;
5410
5411    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5412    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5413
5414    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5415        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5416    }
5417    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5418        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5419    };
5420
5421    let local_var_req = local_var_req_builder.build()?;
5422    let local_var_resp = local_var_client.execute(local_var_req).await?;
5423
5424    let local_var_status = local_var_resp.status();
5425    let local_var_content = local_var_resp.text().await?;
5426
5427    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5428        Ok(())
5429    } else {
5430        let local_var_entity: Option<DeleteSipDomainError> = serde_json::from_str(&local_var_content).ok();
5431        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5432        Err(Error::ResponseError(local_var_error))
5433    }
5434}
5435
5436/// Delete an IpAccessControlList from the requested account
5437pub async fn delete_sip_ip_access_control_list(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteSipIpAccessControlListError>> {
5438    let local_var_configuration = configuration;
5439
5440    let local_var_client = &local_var_configuration.client;
5441
5442    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5443    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5444
5445    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5446        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5447    }
5448    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5449        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5450    };
5451
5452    let local_var_req = local_var_req_builder.build()?;
5453    let local_var_resp = local_var_client.execute(local_var_req).await?;
5454
5455    let local_var_status = local_var_resp.status();
5456    let local_var_content = local_var_resp.text().await?;
5457
5458    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5459        Ok(())
5460    } else {
5461        let local_var_entity: Option<DeleteSipIpAccessControlListError> = serde_json::from_str(&local_var_content).ok();
5462        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5463        Err(Error::ResponseError(local_var_error))
5464    }
5465}
5466
5467/// Delete an IpAccessControlListMapping resource.
5468pub async fn delete_sip_ip_access_control_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<(), Error<DeleteSipIpAccessControlListMappingError>> {
5469    let local_var_configuration = configuration;
5470
5471    let local_var_client = &local_var_configuration.client;
5472
5473    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/IpAccessControlListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
5474    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5475
5476    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5477        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5478    }
5479    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5480        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5481    };
5482
5483    let local_var_req = local_var_req_builder.build()?;
5484    let local_var_resp = local_var_client.execute(local_var_req).await?;
5485
5486    let local_var_status = local_var_resp.status();
5487    let local_var_content = local_var_resp.text().await?;
5488
5489    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5490        Ok(())
5491    } else {
5492        let local_var_entity: Option<DeleteSipIpAccessControlListMappingError> = serde_json::from_str(&local_var_content).ok();
5493        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5494        Err(Error::ResponseError(local_var_error))
5495    }
5496}
5497
5498/// Delete an IpAddress resource.
5499pub async fn delete_sip_ip_address(configuration: &configuration::Configuration, account_sid: &str, ip_access_control_list_sid: &str, sid: &str) -> Result<(), Error<DeleteSipIpAddressError>> {
5500    let local_var_configuration = configuration;
5501
5502    let local_var_client = &local_var_configuration.client;
5503
5504    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid), Sid=crate::apis::urlencode(sid));
5505    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5506
5507    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5508        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5509    }
5510    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5511        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5512    };
5513
5514    let local_var_req = local_var_req_builder.build()?;
5515    let local_var_resp = local_var_client.execute(local_var_req).await?;
5516
5517    let local_var_status = local_var_resp.status();
5518    let local_var_content = local_var_resp.text().await?;
5519
5520    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5521        Ok(())
5522    } else {
5523        let local_var_entity: Option<DeleteSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
5524        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5525        Err(Error::ResponseError(local_var_error))
5526    }
5527}
5528
5529/// Delete a transcription from the account used to make the request
5530pub async fn delete_transcription(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteTranscriptionError>> {
5531    let local_var_configuration = configuration;
5532
5533    let local_var_client = &local_var_configuration.client;
5534
5535    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Transcriptions/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5536    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5537
5538    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5539        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5540    }
5541    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5542        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5543    };
5544
5545    let local_var_req = local_var_req_builder.build()?;
5546    let local_var_resp = local_var_client.execute(local_var_req).await?;
5547
5548    let local_var_status = local_var_resp.status();
5549    let local_var_content = local_var_resp.text().await?;
5550
5551    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5552        Ok(())
5553    } else {
5554        let local_var_entity: Option<DeleteTranscriptionError> = serde_json::from_str(&local_var_content).ok();
5555        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5556        Err(Error::ResponseError(local_var_error))
5557    }
5558}
5559
5560/// 
5561pub async fn delete_usage_trigger(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<(), Error<DeleteUsageTriggerError>> {
5562    let local_var_configuration = configuration;
5563
5564    let local_var_client = &local_var_configuration.client;
5565
5566    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Triggers/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5567    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5568
5569    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5570        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5571    }
5572    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5573        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5574    };
5575
5576    let local_var_req = local_var_req_builder.build()?;
5577    let local_var_resp = local_var_client.execute(local_var_req).await?;
5578
5579    let local_var_status = local_var_resp.status();
5580    let local_var_content = local_var_resp.text().await?;
5581
5582    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5583        Ok(())
5584    } else {
5585        let local_var_entity: Option<DeleteUsageTriggerError> = serde_json::from_str(&local_var_content).ok();
5586        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5587        Err(Error::ResponseError(local_var_error))
5588    }
5589}
5590
5591/// Delete a specific User Defined Message Subscription.
5592pub async fn delete_user_defined_message_subscription(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, sid: &str) -> Result<(), Error<DeleteUserDefinedMessageSubscriptionError>> {
5593    let local_var_configuration = configuration;
5594
5595    let local_var_client = &local_var_configuration.client;
5596
5597    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/UserDefinedMessageSubscriptions/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid), Sid=crate::apis::urlencode(sid));
5598    let mut local_var_req_builder = local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());
5599
5600    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5601        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5602    }
5603    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5604        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5605    };
5606
5607    let local_var_req = local_var_req_builder.build()?;
5608    let local_var_resp = local_var_client.execute(local_var_req).await?;
5609
5610    let local_var_status = local_var_resp.status();
5611    let local_var_content = local_var_resp.text().await?;
5612
5613    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5614        Ok(())
5615    } else {
5616        let local_var_entity: Option<DeleteUserDefinedMessageSubscriptionError> = serde_json::from_str(&local_var_content).ok();
5617        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5618        Err(Error::ResponseError(local_var_error))
5619    }
5620}
5621
5622/// Fetch the account specified by the provided Account Sid
5623pub async fn fetch_account(configuration: &configuration::Configuration, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccount, Error<FetchAccountError>> {
5624    let local_var_configuration = configuration;
5625
5626    let local_var_client = &local_var_configuration.client;
5627
5628    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{Sid}.json", local_var_configuration.base_path, Sid=crate::apis::urlencode(sid));
5629    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5630
5631    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5632        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5633    }
5634    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5635        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5636    };
5637
5638    let local_var_req = local_var_req_builder.build()?;
5639    let local_var_resp = local_var_client.execute(local_var_req).await?;
5640
5641    let local_var_status = local_var_resp.status();
5642    let local_var_content = local_var_resp.text().await?;
5643
5644    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5645        serde_json::from_str(&local_var_content).map_err(Error::from)
5646    } else {
5647        let local_var_entity: Option<FetchAccountError> = serde_json::from_str(&local_var_content).ok();
5648        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5649        Err(Error::ResponseError(local_var_error))
5650    }
5651}
5652
5653/// 
5654pub async fn fetch_address(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodAddress, Error<FetchAddressError>> {
5655    let local_var_configuration = configuration;
5656
5657    let local_var_client = &local_var_configuration.client;
5658
5659    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Addresses/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5660    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5661
5662    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5663        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5664    }
5665    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5666        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5667    };
5668
5669    let local_var_req = local_var_req_builder.build()?;
5670    let local_var_resp = local_var_client.execute(local_var_req).await?;
5671
5672    let local_var_status = local_var_resp.status();
5673    let local_var_content = local_var_resp.text().await?;
5674
5675    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5676        serde_json::from_str(&local_var_content).map_err(Error::from)
5677    } else {
5678        let local_var_entity: Option<FetchAddressError> = serde_json::from_str(&local_var_content).ok();
5679        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5680        Err(Error::ResponseError(local_var_error))
5681    }
5682}
5683
5684/// Fetch the application specified by the provided sid
5685pub async fn fetch_application(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodApplication, Error<FetchApplicationError>> {
5686    let local_var_configuration = configuration;
5687
5688    let local_var_client = &local_var_configuration.client;
5689
5690    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5691    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5692
5693    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5694        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5695    }
5696    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5697        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5698    };
5699
5700    let local_var_req = local_var_req_builder.build()?;
5701    let local_var_resp = local_var_client.execute(local_var_req).await?;
5702
5703    let local_var_status = local_var_resp.status();
5704    let local_var_content = local_var_resp.text().await?;
5705
5706    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5707        serde_json::from_str(&local_var_content).map_err(Error::from)
5708    } else {
5709        let local_var_entity: Option<FetchApplicationError> = serde_json::from_str(&local_var_content).ok();
5710        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5711        Err(Error::ResponseError(local_var_error))
5712    }
5713}
5714
5715/// Fetch an instance of an authorized-connect-app
5716pub async fn fetch_authorized_connect_app(configuration: &configuration::Configuration, account_sid: &str, connect_app_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodAuthorizedConnectApp, Error<FetchAuthorizedConnectAppError>> {
5717    let local_var_configuration = configuration;
5718
5719    let local_var_client = &local_var_configuration.client;
5720
5721    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AuthorizedConnectApps/{ConnectAppSid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConnectAppSid=crate::apis::urlencode(connect_app_sid));
5722    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5723
5724    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5725        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5726    }
5727    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5728        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5729    };
5730
5731    let local_var_req = local_var_req_builder.build()?;
5732    let local_var_resp = local_var_client.execute(local_var_req).await?;
5733
5734    let local_var_status = local_var_resp.status();
5735    let local_var_content = local_var_resp.text().await?;
5736
5737    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5738        serde_json::from_str(&local_var_content).map_err(Error::from)
5739    } else {
5740        let local_var_entity: Option<FetchAuthorizedConnectAppError> = serde_json::from_str(&local_var_content).ok();
5741        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5742        Err(Error::ResponseError(local_var_error))
5743    }
5744}
5745
5746/// 
5747pub async fn fetch_available_phone_number_country(configuration: &configuration::Configuration, account_sid: &str, country_code: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodAvailablePhoneNumberCountry, Error<FetchAvailablePhoneNumberCountryError>> {
5748    let local_var_configuration = configuration;
5749
5750    let local_var_client = &local_var_configuration.client;
5751
5752    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AvailablePhoneNumbers/{CountryCode}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CountryCode=crate::apis::urlencode(country_code));
5753    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5754
5755    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5756        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5757    }
5758    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5759        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5760    };
5761
5762    let local_var_req = local_var_req_builder.build()?;
5763    let local_var_resp = local_var_client.execute(local_var_req).await?;
5764
5765    let local_var_status = local_var_resp.status();
5766    let local_var_content = local_var_resp.text().await?;
5767
5768    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5769        serde_json::from_str(&local_var_content).map_err(Error::from)
5770    } else {
5771        let local_var_entity: Option<FetchAvailablePhoneNumberCountryError> = serde_json::from_str(&local_var_content).ok();
5772        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5773        Err(Error::ResponseError(local_var_error))
5774    }
5775}
5776
5777/// Fetch the balance for an Account based on Account Sid. Balance changes may not be reflected immediately. Child accounts do not contain balance information
5778pub async fn fetch_balance(configuration: &configuration::Configuration, account_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodBalance, Error<FetchBalanceError>> {
5779    let local_var_configuration = configuration;
5780
5781    let local_var_client = &local_var_configuration.client;
5782
5783    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Balance.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
5784    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5785
5786    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5787        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5788    }
5789    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5790        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5791    };
5792
5793    let local_var_req = local_var_req_builder.build()?;
5794    let local_var_resp = local_var_client.execute(local_var_req).await?;
5795
5796    let local_var_status = local_var_resp.status();
5797    let local_var_content = local_var_resp.text().await?;
5798
5799    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5800        serde_json::from_str(&local_var_content).map_err(Error::from)
5801    } else {
5802        let local_var_entity: Option<FetchBalanceError> = serde_json::from_str(&local_var_content).ok();
5803        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5804        Err(Error::ResponseError(local_var_error))
5805    }
5806}
5807
5808/// Fetch the call specified by the provided Call SID
5809pub async fn fetch_call(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCall, Error<FetchCallError>> {
5810    let local_var_configuration = configuration;
5811
5812    let local_var_client = &local_var_configuration.client;
5813
5814    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5815    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5816
5817    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5818        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5819    }
5820    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5821        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5822    };
5823
5824    let local_var_req = local_var_req_builder.build()?;
5825    let local_var_resp = local_var_client.execute(local_var_req).await?;
5826
5827    let local_var_status = local_var_resp.status();
5828    let local_var_content = local_var_resp.text().await?;
5829
5830    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5831        serde_json::from_str(&local_var_content).map_err(Error::from)
5832    } else {
5833        let local_var_entity: Option<FetchCallError> = serde_json::from_str(&local_var_content).ok();
5834        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5835        Err(Error::ResponseError(local_var_error))
5836    }
5837}
5838
5839/// Fetch a Feedback resource from a call
5840pub async fn fetch_call_feedback(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodCallFeedback, Error<FetchCallFeedbackError>> {
5841    let local_var_configuration = configuration;
5842
5843    let local_var_client = &local_var_configuration.client;
5844
5845    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Feedback.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
5846    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5847
5848    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5849        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5850    }
5851    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5852        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5853    };
5854
5855    let local_var_req = local_var_req_builder.build()?;
5856    let local_var_resp = local_var_client.execute(local_var_req).await?;
5857
5858    let local_var_status = local_var_resp.status();
5859    let local_var_content = local_var_resp.text().await?;
5860
5861    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5862        serde_json::from_str(&local_var_content).map_err(Error::from)
5863    } else {
5864        let local_var_entity: Option<FetchCallFeedbackError> = serde_json::from_str(&local_var_content).ok();
5865        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5866        Err(Error::ResponseError(local_var_error))
5867    }
5868}
5869
5870/// Fetch a FeedbackSummary resource from a call
5871pub async fn fetch_call_feedback_summary(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodCallFeedbackSummary, Error<FetchCallFeedbackSummaryError>> {
5872    let local_var_configuration = configuration;
5873
5874    let local_var_client = &local_var_configuration.client;
5875
5876    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/FeedbackSummary/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5877    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5878
5879    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5880        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5881    }
5882    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5883        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5884    };
5885
5886    let local_var_req = local_var_req_builder.build()?;
5887    let local_var_resp = local_var_client.execute(local_var_req).await?;
5888
5889    let local_var_status = local_var_resp.status();
5890    let local_var_content = local_var_resp.text().await?;
5891
5892    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5893        serde_json::from_str(&local_var_content).map_err(Error::from)
5894    } else {
5895        let local_var_entity: Option<FetchCallFeedbackSummaryError> = serde_json::from_str(&local_var_content).ok();
5896        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5897        Err(Error::ResponseError(local_var_error))
5898    }
5899}
5900
5901/// 
5902pub async fn fetch_call_notification(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodCallNotificationInstance, Error<FetchCallNotificationError>> {
5903    let local_var_configuration = configuration;
5904
5905    let local_var_client = &local_var_configuration.client;
5906
5907    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Notifications/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid), Sid=crate::apis::urlencode(sid));
5908    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5909
5910    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5911        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5912    }
5913    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5914        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5915    };
5916
5917    let local_var_req = local_var_req_builder.build()?;
5918    let local_var_resp = local_var_client.execute(local_var_req).await?;
5919
5920    let local_var_status = local_var_resp.status();
5921    let local_var_content = local_var_resp.text().await?;
5922
5923    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5924        serde_json::from_str(&local_var_content).map_err(Error::from)
5925    } else {
5926        let local_var_entity: Option<FetchCallNotificationError> = serde_json::from_str(&local_var_content).ok();
5927        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5928        Err(Error::ResponseError(local_var_error))
5929    }
5930}
5931
5932/// Fetch an instance of a recording for a call
5933pub async fn fetch_call_recording(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodCallRecording, Error<FetchCallRecordingError>> {
5934    let local_var_configuration = configuration;
5935
5936    let local_var_client = &local_var_configuration.client;
5937
5938    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Recordings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid), Sid=crate::apis::urlencode(sid));
5939    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5940
5941    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5942        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5943    }
5944    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5945        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5946    };
5947
5948    let local_var_req = local_var_req_builder.build()?;
5949    let local_var_resp = local_var_client.execute(local_var_req).await?;
5950
5951    let local_var_status = local_var_resp.status();
5952    let local_var_content = local_var_resp.text().await?;
5953
5954    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5955        serde_json::from_str(&local_var_content).map_err(Error::from)
5956    } else {
5957        let local_var_entity: Option<FetchCallRecordingError> = serde_json::from_str(&local_var_content).ok();
5958        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5959        Err(Error::ResponseError(local_var_error))
5960    }
5961}
5962
5963/// Fetch an instance of a conference
5964pub async fn fetch_conference(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodConference, Error<FetchConferenceError>> {
5965    let local_var_configuration = configuration;
5966
5967    let local_var_client = &local_var_configuration.client;
5968
5969    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
5970    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
5971
5972    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
5973        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
5974    }
5975    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
5976        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
5977    };
5978
5979    let local_var_req = local_var_req_builder.build()?;
5980    let local_var_resp = local_var_client.execute(local_var_req).await?;
5981
5982    let local_var_status = local_var_resp.status();
5983    let local_var_content = local_var_resp.text().await?;
5984
5985    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
5986        serde_json::from_str(&local_var_content).map_err(Error::from)
5987    } else {
5988        let local_var_entity: Option<FetchConferenceError> = serde_json::from_str(&local_var_content).ok();
5989        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
5990        Err(Error::ResponseError(local_var_error))
5991    }
5992}
5993
5994/// Fetch an instance of a recording for a call
5995pub async fn fetch_conference_recording(configuration: &configuration::Configuration, account_sid: &str, conference_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodConferencePeriodConferenceRecording, Error<FetchConferenceRecordingError>> {
5996    let local_var_configuration = configuration;
5997
5998    let local_var_client = &local_var_configuration.client;
5999
6000    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{ConferenceSid}/Recordings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConferenceSid=crate::apis::urlencode(conference_sid), Sid=crate::apis::urlencode(sid));
6001    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6002
6003    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6004        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6005    }
6006    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6007        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6008    };
6009
6010    let local_var_req = local_var_req_builder.build()?;
6011    let local_var_resp = local_var_client.execute(local_var_req).await?;
6012
6013    let local_var_status = local_var_resp.status();
6014    let local_var_content = local_var_resp.text().await?;
6015
6016    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6017        serde_json::from_str(&local_var_content).map_err(Error::from)
6018    } else {
6019        let local_var_entity: Option<FetchConferenceRecordingError> = serde_json::from_str(&local_var_content).ok();
6020        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6021        Err(Error::ResponseError(local_var_error))
6022    }
6023}
6024
6025/// Fetch an instance of a connect-app
6026pub async fn fetch_connect_app(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodConnectApp, Error<FetchConnectAppError>> {
6027    let local_var_configuration = configuration;
6028
6029    let local_var_client = &local_var_configuration.client;
6030
6031    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/ConnectApps/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6032    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6033
6034    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6035        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6036    }
6037    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6038        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6039    };
6040
6041    let local_var_req = local_var_req_builder.build()?;
6042    let local_var_resp = local_var_client.execute(local_var_req).await?;
6043
6044    let local_var_status = local_var_resp.status();
6045    let local_var_content = local_var_resp.text().await?;
6046
6047    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6048        serde_json::from_str(&local_var_content).map_err(Error::from)
6049    } else {
6050        let local_var_entity: Option<FetchConnectAppError> = serde_json::from_str(&local_var_content).ok();
6051        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6052        Err(Error::ResponseError(local_var_error))
6053    }
6054}
6055
6056/// Fetch an incoming-phone-number belonging to the account used to make the request.
6057pub async fn fetch_incoming_phone_number(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodIncomingPhoneNumber, Error<FetchIncomingPhoneNumberError>> {
6058    let local_var_configuration = configuration;
6059
6060    let local_var_client = &local_var_configuration.client;
6061
6062    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6063    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6064
6065    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6066        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6067    }
6068    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6069        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6070    };
6071
6072    let local_var_req = local_var_req_builder.build()?;
6073    let local_var_resp = local_var_client.execute(local_var_req).await?;
6074
6075    let local_var_status = local_var_resp.status();
6076    let local_var_content = local_var_resp.text().await?;
6077
6078    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6079        serde_json::from_str(&local_var_content).map_err(Error::from)
6080    } else {
6081        let local_var_entity: Option<FetchIncomingPhoneNumberError> = serde_json::from_str(&local_var_content).ok();
6082        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6083        Err(Error::ResponseError(local_var_error))
6084    }
6085}
6086
6087/// Fetch an instance of an Add-on installation currently assigned to this Number.
6088pub async fn fetch_incoming_phone_number_assigned_add_on(configuration: &configuration::Configuration, account_sid: &str, resource_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodIncomingPhoneNumberPeriodIncomingPhoneNumberAssignedAddOn, Error<FetchIncomingPhoneNumberAssignedAddOnError>> {
6089    let local_var_configuration = configuration;
6090
6091    let local_var_client = &local_var_configuration.client;
6092
6093    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/{ResourceSid}/AssignedAddOns/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ResourceSid=crate::apis::urlencode(resource_sid), Sid=crate::apis::urlencode(sid));
6094    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6095
6096    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6097        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6098    }
6099    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6100        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6101    };
6102
6103    let local_var_req = local_var_req_builder.build()?;
6104    let local_var_resp = local_var_client.execute(local_var_req).await?;
6105
6106    let local_var_status = local_var_resp.status();
6107    let local_var_content = local_var_resp.text().await?;
6108
6109    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6110        serde_json::from_str(&local_var_content).map_err(Error::from)
6111    } else {
6112        let local_var_entity: Option<FetchIncomingPhoneNumberAssignedAddOnError> = serde_json::from_str(&local_var_content).ok();
6113        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6114        Err(Error::ResponseError(local_var_error))
6115    }
6116}
6117
6118/// Fetch an instance of an Extension for the Assigned Add-on.
6119pub async fn fetch_incoming_phone_number_assigned_add_on_extension(configuration: &configuration::Configuration, account_sid: &str, resource_sid: &str, assigned_add_on_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodIncomingPhoneNumberPeriodIncomingPhoneNumberAssignedAddOnPeriodIncomingPhoneNumberAssignedAddOnExtension, Error<FetchIncomingPhoneNumberAssignedAddOnExtensionError>> {
6120    let local_var_configuration = configuration;
6121
6122    let local_var_client = &local_var_configuration.client;
6123
6124    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/{ResourceSid}/AssignedAddOns/{AssignedAddOnSid}/Extensions/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ResourceSid=crate::apis::urlencode(resource_sid), AssignedAddOnSid=crate::apis::urlencode(assigned_add_on_sid), Sid=crate::apis::urlencode(sid));
6125    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6126
6127    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6128        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6129    }
6130    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6131        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6132    };
6133
6134    let local_var_req = local_var_req_builder.build()?;
6135    let local_var_resp = local_var_client.execute(local_var_req).await?;
6136
6137    let local_var_status = local_var_resp.status();
6138    let local_var_content = local_var_resp.text().await?;
6139
6140    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6141        serde_json::from_str(&local_var_content).map_err(Error::from)
6142    } else {
6143        let local_var_entity: Option<FetchIncomingPhoneNumberAssignedAddOnExtensionError> = serde_json::from_str(&local_var_content).ok();
6144        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6145        Err(Error::ResponseError(local_var_error))
6146    }
6147}
6148
6149/// 
6150pub async fn fetch_key(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodKey, Error<FetchKeyError>> {
6151    let local_var_configuration = configuration;
6152
6153    let local_var_client = &local_var_configuration.client;
6154
6155    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Keys/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6156    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6157
6158    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6159        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6160    }
6161    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6162        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6163    };
6164
6165    let local_var_req = local_var_req_builder.build()?;
6166    let local_var_resp = local_var_client.execute(local_var_req).await?;
6167
6168    let local_var_status = local_var_resp.status();
6169    let local_var_content = local_var_resp.text().await?;
6170
6171    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6172        serde_json::from_str(&local_var_content).map_err(Error::from)
6173    } else {
6174        let local_var_entity: Option<FetchKeyError> = serde_json::from_str(&local_var_content).ok();
6175        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6176        Err(Error::ResponseError(local_var_error))
6177    }
6178}
6179
6180/// Fetch a single media instance belonging to the account used to make the request
6181pub async fn fetch_media(configuration: &configuration::Configuration, account_sid: &str, message_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodMessagePeriodMedia, Error<FetchMediaError>> {
6182    let local_var_configuration = configuration;
6183
6184    let local_var_client = &local_var_configuration.client;
6185
6186    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{MessageSid}/Media/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), MessageSid=crate::apis::urlencode(message_sid), Sid=crate::apis::urlencode(sid));
6187    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6188
6189    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6190        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6191    }
6192    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6193        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6194    };
6195
6196    let local_var_req = local_var_req_builder.build()?;
6197    let local_var_resp = local_var_client.execute(local_var_req).await?;
6198
6199    let local_var_status = local_var_resp.status();
6200    let local_var_content = local_var_resp.text().await?;
6201
6202    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6203        serde_json::from_str(&local_var_content).map_err(Error::from)
6204    } else {
6205        let local_var_entity: Option<FetchMediaError> = serde_json::from_str(&local_var_content).ok();
6206        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6207        Err(Error::ResponseError(local_var_error))
6208    }
6209}
6210
6211/// Fetch a specific member from the queue
6212pub async fn fetch_member(configuration: &configuration::Configuration, account_sid: &str, queue_sid: &str, call_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodQueuePeriodMember, Error<FetchMemberError>> {
6213    let local_var_configuration = configuration;
6214
6215    let local_var_client = &local_var_configuration.client;
6216
6217    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Queues/{QueueSid}/Members/{CallSid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), QueueSid=crate::apis::urlencode(queue_sid), CallSid=crate::apis::urlencode(call_sid));
6218    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6219
6220    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6221        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6222    }
6223    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6224        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6225    };
6226
6227    let local_var_req = local_var_req_builder.build()?;
6228    let local_var_resp = local_var_client.execute(local_var_req).await?;
6229
6230    let local_var_status = local_var_resp.status();
6231    let local_var_content = local_var_resp.text().await?;
6232
6233    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6234        serde_json::from_str(&local_var_content).map_err(Error::from)
6235    } else {
6236        let local_var_entity: Option<FetchMemberError> = serde_json::from_str(&local_var_content).ok();
6237        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6238        Err(Error::ResponseError(local_var_error))
6239    }
6240}
6241
6242/// Fetch a message belonging to the account used to make the request
6243pub async fn fetch_message(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodMessage, Error<FetchMessageError>> {
6244    let local_var_configuration = configuration;
6245
6246    let local_var_client = &local_var_configuration.client;
6247
6248    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6249    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6250
6251    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6252        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6253    }
6254    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6255        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6256    };
6257
6258    let local_var_req = local_var_req_builder.build()?;
6259    let local_var_resp = local_var_client.execute(local_var_req).await?;
6260
6261    let local_var_status = local_var_resp.status();
6262    let local_var_content = local_var_resp.text().await?;
6263
6264    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6265        serde_json::from_str(&local_var_content).map_err(Error::from)
6266    } else {
6267        let local_var_entity: Option<FetchMessageError> = serde_json::from_str(&local_var_content).ok();
6268        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6269        Err(Error::ResponseError(local_var_error))
6270    }
6271}
6272
6273/// Fetch a notification belonging to the account used to make the request
6274pub async fn fetch_notification(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodNotificationInstance, Error<FetchNotificationError>> {
6275    let local_var_configuration = configuration;
6276
6277    let local_var_client = &local_var_configuration.client;
6278
6279    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Notifications/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6280    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6281
6282    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6283        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6284    }
6285    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6286        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6287    };
6288
6289    let local_var_req = local_var_req_builder.build()?;
6290    let local_var_resp = local_var_client.execute(local_var_req).await?;
6291
6292    let local_var_status = local_var_resp.status();
6293    let local_var_content = local_var_resp.text().await?;
6294
6295    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6296        serde_json::from_str(&local_var_content).map_err(Error::from)
6297    } else {
6298        let local_var_entity: Option<FetchNotificationError> = serde_json::from_str(&local_var_content).ok();
6299        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6300        Err(Error::ResponseError(local_var_error))
6301    }
6302}
6303
6304/// Fetch an outgoing-caller-id belonging to the account used to make the request
6305pub async fn fetch_outgoing_caller_id(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodOutgoingCallerId, Error<FetchOutgoingCallerIdError>> {
6306    let local_var_configuration = configuration;
6307
6308    let local_var_client = &local_var_configuration.client;
6309
6310    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/OutgoingCallerIds/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6311    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6312
6313    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6314        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6315    }
6316    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6317        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6318    };
6319
6320    let local_var_req = local_var_req_builder.build()?;
6321    let local_var_resp = local_var_client.execute(local_var_req).await?;
6322
6323    let local_var_status = local_var_resp.status();
6324    let local_var_content = local_var_resp.text().await?;
6325
6326    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6327        serde_json::from_str(&local_var_content).map_err(Error::from)
6328    } else {
6329        let local_var_entity: Option<FetchOutgoingCallerIdError> = serde_json::from_str(&local_var_content).ok();
6330        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6331        Err(Error::ResponseError(local_var_error))
6332    }
6333}
6334
6335/// Fetch an instance of a participant
6336pub async fn fetch_participant(configuration: &configuration::Configuration, account_sid: &str, conference_sid: &str, call_sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodConferencePeriodParticipant, Error<FetchParticipantError>> {
6337    let local_var_configuration = configuration;
6338
6339    let local_var_client = &local_var_configuration.client;
6340
6341    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{ConferenceSid}/Participants/{CallSid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConferenceSid=crate::apis::urlencode(conference_sid), CallSid=crate::apis::urlencode(call_sid));
6342    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6343
6344    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6345        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6346    }
6347    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6348        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6349    };
6350
6351    let local_var_req = local_var_req_builder.build()?;
6352    let local_var_resp = local_var_client.execute(local_var_req).await?;
6353
6354    let local_var_status = local_var_resp.status();
6355    let local_var_content = local_var_resp.text().await?;
6356
6357    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6358        serde_json::from_str(&local_var_content).map_err(Error::from)
6359    } else {
6360        let local_var_entity: Option<FetchParticipantError> = serde_json::from_str(&local_var_content).ok();
6361        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6362        Err(Error::ResponseError(local_var_error))
6363    }
6364}
6365
6366/// Fetch an instance of a queue identified by the QueueSid
6367pub async fn fetch_queue(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodQueue, Error<FetchQueueError>> {
6368    let local_var_configuration = configuration;
6369
6370    let local_var_client = &local_var_configuration.client;
6371
6372    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Queues/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6373    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6374
6375    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6376        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6377    }
6378    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6379        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6380    };
6381
6382    let local_var_req = local_var_req_builder.build()?;
6383    let local_var_resp = local_var_client.execute(local_var_req).await?;
6384
6385    let local_var_status = local_var_resp.status();
6386    let local_var_content = local_var_resp.text().await?;
6387
6388    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6389        serde_json::from_str(&local_var_content).map_err(Error::from)
6390    } else {
6391        let local_var_entity: Option<FetchQueueError> = serde_json::from_str(&local_var_content).ok();
6392        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6393        Err(Error::ResponseError(local_var_error))
6394    }
6395}
6396
6397/// Fetch an instance of a recording
6398pub async fn fetch_recording(configuration: &configuration::Configuration, account_sid: &str, sid: &str, include_soft_deleted: Option<bool>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodRecording, Error<FetchRecordingError>> {
6399    let local_var_configuration = configuration;
6400
6401    let local_var_client = &local_var_configuration.client;
6402
6403    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6404    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6405
6406    if let Some(ref local_var_str) = include_soft_deleted {
6407        local_var_req_builder = local_var_req_builder.query(&[("IncludeSoftDeleted", &local_var_str.to_string())]);
6408    }
6409    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6410        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6411    }
6412    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6413        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6414    };
6415
6416    let local_var_req = local_var_req_builder.build()?;
6417    let local_var_resp = local_var_client.execute(local_var_req).await?;
6418
6419    let local_var_status = local_var_resp.status();
6420    let local_var_content = local_var_resp.text().await?;
6421
6422    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6423        serde_json::from_str(&local_var_content).map_err(Error::from)
6424    } else {
6425        let local_var_entity: Option<FetchRecordingError> = serde_json::from_str(&local_var_content).ok();
6426        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6427        Err(Error::ResponseError(local_var_error))
6428    }
6429}
6430
6431/// Fetch an instance of an AddOnResult
6432pub async fn fetch_recording_add_on_result(configuration: &configuration::Configuration, account_sid: &str, reference_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodRecordingPeriodRecordingAddOnResult, Error<FetchRecordingAddOnResultError>> {
6433    let local_var_configuration = configuration;
6434
6435    let local_var_client = &local_var_configuration.client;
6436
6437    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{ReferenceSid}/AddOnResults/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ReferenceSid=crate::apis::urlencode(reference_sid), Sid=crate::apis::urlencode(sid));
6438    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6439
6440    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6441        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6442    }
6443    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6444        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6445    };
6446
6447    let local_var_req = local_var_req_builder.build()?;
6448    let local_var_resp = local_var_client.execute(local_var_req).await?;
6449
6450    let local_var_status = local_var_resp.status();
6451    let local_var_content = local_var_resp.text().await?;
6452
6453    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6454        serde_json::from_str(&local_var_content).map_err(Error::from)
6455    } else {
6456        let local_var_entity: Option<FetchRecordingAddOnResultError> = serde_json::from_str(&local_var_content).ok();
6457        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6458        Err(Error::ResponseError(local_var_error))
6459    }
6460}
6461
6462/// Fetch an instance of a result payload
6463pub async fn fetch_recording_add_on_result_payload(configuration: &configuration::Configuration, account_sid: &str, reference_sid: &str, add_on_result_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodRecordingPeriodRecordingAddOnResultPeriodRecordingAddOnResultPayload, Error<FetchRecordingAddOnResultPayloadError>> {
6464    let local_var_configuration = configuration;
6465
6466    let local_var_client = &local_var_configuration.client;
6467
6468    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{ReferenceSid}/AddOnResults/{AddOnResultSid}/Payloads/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ReferenceSid=crate::apis::urlencode(reference_sid), AddOnResultSid=crate::apis::urlencode(add_on_result_sid), Sid=crate::apis::urlencode(sid));
6469    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6470
6471    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6472        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6473    }
6474    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6475        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6476    };
6477
6478    let local_var_req = local_var_req_builder.build()?;
6479    let local_var_resp = local_var_client.execute(local_var_req).await?;
6480
6481    let local_var_status = local_var_resp.status();
6482    let local_var_content = local_var_resp.text().await?;
6483
6484    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6485        serde_json::from_str(&local_var_content).map_err(Error::from)
6486    } else {
6487        let local_var_entity: Option<FetchRecordingAddOnResultPayloadError> = serde_json::from_str(&local_var_content).ok();
6488        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6489        Err(Error::ResponseError(local_var_error))
6490    }
6491}
6492
6493/// 
6494pub async fn fetch_recording_transcription(configuration: &configuration::Configuration, account_sid: &str, recording_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodRecordingPeriodRecordingTranscription, Error<FetchRecordingTranscriptionError>> {
6495    let local_var_configuration = configuration;
6496
6497    let local_var_client = &local_var_configuration.client;
6498
6499    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{RecordingSid}/Transcriptions/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), RecordingSid=crate::apis::urlencode(recording_sid), Sid=crate::apis::urlencode(sid));
6500    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6501
6502    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6503        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6504    }
6505    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6506        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6507    };
6508
6509    let local_var_req = local_var_req_builder.build()?;
6510    let local_var_resp = local_var_client.execute(local_var_req).await?;
6511
6512    let local_var_status = local_var_resp.status();
6513    let local_var_content = local_var_resp.text().await?;
6514
6515    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6516        serde_json::from_str(&local_var_content).map_err(Error::from)
6517    } else {
6518        let local_var_entity: Option<FetchRecordingTranscriptionError> = serde_json::from_str(&local_var_content).ok();
6519        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6520        Err(Error::ResponseError(local_var_error))
6521    }
6522}
6523
6524/// Fetch an instance of a short code
6525pub async fn fetch_short_code(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodShortCode, Error<FetchShortCodeError>> {
6526    let local_var_configuration = configuration;
6527
6528    let local_var_client = &local_var_configuration.client;
6529
6530    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SMS/ShortCodes/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6531    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6532
6533    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6534        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6535    }
6536    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6537        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6538    };
6539
6540    let local_var_req = local_var_req_builder.build()?;
6541    let local_var_resp = local_var_client.execute(local_var_req).await?;
6542
6543    let local_var_status = local_var_resp.status();
6544    let local_var_content = local_var_resp.text().await?;
6545
6546    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6547        serde_json::from_str(&local_var_content).map_err(Error::from)
6548    } else {
6549        let local_var_entity: Option<FetchShortCodeError> = serde_json::from_str(&local_var_content).ok();
6550        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6551        Err(Error::ResponseError(local_var_error))
6552    }
6553}
6554
6555/// 
6556pub async fn fetch_signing_key(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSigningKey, Error<FetchSigningKeyError>> {
6557    let local_var_configuration = configuration;
6558
6559    let local_var_client = &local_var_configuration.client;
6560
6561    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SigningKeys/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6562    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6563
6564    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6565        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6566    }
6567    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6568        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6569    };
6570
6571    let local_var_req = local_var_req_builder.build()?;
6572    let local_var_resp = local_var_client.execute(local_var_req).await?;
6573
6574    let local_var_status = local_var_resp.status();
6575    let local_var_content = local_var_resp.text().await?;
6576
6577    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6578        serde_json::from_str(&local_var_content).map_err(Error::from)
6579    } else {
6580        let local_var_entity: Option<FetchSigningKeyError> = serde_json::from_str(&local_var_content).ok();
6581        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6582        Err(Error::ResponseError(local_var_error))
6583    }
6584}
6585
6586/// Fetch a specific instance of a credential list mapping
6587pub async fn fetch_sip_auth_calls_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipAuthPeriodSipAuthCallsPeriodSipAuthCallsCredentialListMapping, Error<FetchSipAuthCallsCredentialListMappingError>> {
6588    let local_var_configuration = configuration;
6589
6590    let local_var_client = &local_var_configuration.client;
6591
6592    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/CredentialListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
6593    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6594
6595    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6596        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6597    }
6598    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6599        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6600    };
6601
6602    let local_var_req = local_var_req_builder.build()?;
6603    let local_var_resp = local_var_client.execute(local_var_req).await?;
6604
6605    let local_var_status = local_var_resp.status();
6606    let local_var_content = local_var_resp.text().await?;
6607
6608    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6609        serde_json::from_str(&local_var_content).map_err(Error::from)
6610    } else {
6611        let local_var_entity: Option<FetchSipAuthCallsCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
6612        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6613        Err(Error::ResponseError(local_var_error))
6614    }
6615}
6616
6617/// Fetch a specific instance of an IP Access Control List mapping
6618pub async fn fetch_sip_auth_calls_ip_access_control_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipAuthPeriodSipAuthCallsPeriodSipAuthCallsIpAccessControlListMapping, Error<FetchSipAuthCallsIpAccessControlListMappingError>> {
6619    let local_var_configuration = configuration;
6620
6621    let local_var_client = &local_var_configuration.client;
6622
6623    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/IpAccessControlListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
6624    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6625
6626    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6627        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6628    }
6629    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6630        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6631    };
6632
6633    let local_var_req = local_var_req_builder.build()?;
6634    let local_var_resp = local_var_client.execute(local_var_req).await?;
6635
6636    let local_var_status = local_var_resp.status();
6637    let local_var_content = local_var_resp.text().await?;
6638
6639    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6640        serde_json::from_str(&local_var_content).map_err(Error::from)
6641    } else {
6642        let local_var_entity: Option<FetchSipAuthCallsIpAccessControlListMappingError> = serde_json::from_str(&local_var_content).ok();
6643        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6644        Err(Error::ResponseError(local_var_error))
6645    }
6646}
6647
6648/// Fetch a specific instance of a credential list mapping
6649pub async fn fetch_sip_auth_registrations_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipAuthPeriodSipAuthRegistrationsPeriodSipAuthRegistrationsCredentialListMapping, Error<FetchSipAuthRegistrationsCredentialListMappingError>> {
6650    let local_var_configuration = configuration;
6651
6652    let local_var_client = &local_var_configuration.client;
6653
6654    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Registrations/CredentialListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
6655    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6656
6657    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6658        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6659    }
6660    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6661        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6662    };
6663
6664    let local_var_req = local_var_req_builder.build()?;
6665    let local_var_resp = local_var_client.execute(local_var_req).await?;
6666
6667    let local_var_status = local_var_resp.status();
6668    let local_var_content = local_var_resp.text().await?;
6669
6670    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6671        serde_json::from_str(&local_var_content).map_err(Error::from)
6672    } else {
6673        let local_var_entity: Option<FetchSipAuthRegistrationsCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
6674        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6675        Err(Error::ResponseError(local_var_error))
6676    }
6677}
6678
6679/// Fetch a single credential.
6680pub async fn fetch_sip_credential(configuration: &configuration::Configuration, account_sid: &str, credential_list_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipCredentialListPeriodSipCredential, Error<FetchSipCredentialError>> {
6681    let local_var_configuration = configuration;
6682
6683    let local_var_client = &local_var_configuration.client;
6684
6685    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists/{CredentialListSid}/Credentials/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CredentialListSid=crate::apis::urlencode(credential_list_sid), Sid=crate::apis::urlencode(sid));
6686    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6687
6688    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6689        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6690    }
6691    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6692        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6693    };
6694
6695    let local_var_req = local_var_req_builder.build()?;
6696    let local_var_resp = local_var_client.execute(local_var_req).await?;
6697
6698    let local_var_status = local_var_resp.status();
6699    let local_var_content = local_var_resp.text().await?;
6700
6701    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6702        serde_json::from_str(&local_var_content).map_err(Error::from)
6703    } else {
6704        let local_var_entity: Option<FetchSipCredentialError> = serde_json::from_str(&local_var_content).ok();
6705        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6706        Err(Error::ResponseError(local_var_error))
6707    }
6708}
6709
6710/// Get a Credential List
6711pub async fn fetch_sip_credential_list(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipCredentialList, Error<FetchSipCredentialListError>> {
6712    let local_var_configuration = configuration;
6713
6714    let local_var_client = &local_var_configuration.client;
6715
6716    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6717    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6718
6719    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6720        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6721    }
6722    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6723        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6724    };
6725
6726    let local_var_req = local_var_req_builder.build()?;
6727    let local_var_resp = local_var_client.execute(local_var_req).await?;
6728
6729    let local_var_status = local_var_resp.status();
6730    let local_var_content = local_var_resp.text().await?;
6731
6732    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6733        serde_json::from_str(&local_var_content).map_err(Error::from)
6734    } else {
6735        let local_var_entity: Option<FetchSipCredentialListError> = serde_json::from_str(&local_var_content).ok();
6736        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6737        Err(Error::ResponseError(local_var_error))
6738    }
6739}
6740
6741/// Fetch a single CredentialListMapping resource from an account.
6742pub async fn fetch_sip_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipCredentialListMapping, Error<FetchSipCredentialListMappingError>> {
6743    let local_var_configuration = configuration;
6744
6745    let local_var_client = &local_var_configuration.client;
6746
6747    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/CredentialListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
6748    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6749
6750    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6751        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6752    }
6753    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6754        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6755    };
6756
6757    let local_var_req = local_var_req_builder.build()?;
6758    let local_var_resp = local_var_client.execute(local_var_req).await?;
6759
6760    let local_var_status = local_var_resp.status();
6761    let local_var_content = local_var_resp.text().await?;
6762
6763    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6764        serde_json::from_str(&local_var_content).map_err(Error::from)
6765    } else {
6766        let local_var_entity: Option<FetchSipCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
6767        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6768        Err(Error::ResponseError(local_var_error))
6769    }
6770}
6771
6772/// Fetch an instance of a Domain
6773pub async fn fetch_sip_domain(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomain, Error<FetchSipDomainError>> {
6774    let local_var_configuration = configuration;
6775
6776    let local_var_client = &local_var_configuration.client;
6777
6778    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6779    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6780
6781    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6782        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6783    }
6784    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6785        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6786    };
6787
6788    let local_var_req = local_var_req_builder.build()?;
6789    let local_var_resp = local_var_client.execute(local_var_req).await?;
6790
6791    let local_var_status = local_var_resp.status();
6792    let local_var_content = local_var_resp.text().await?;
6793
6794    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6795        serde_json::from_str(&local_var_content).map_err(Error::from)
6796    } else {
6797        let local_var_entity: Option<FetchSipDomainError> = serde_json::from_str(&local_var_content).ok();
6798        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6799        Err(Error::ResponseError(local_var_error))
6800    }
6801}
6802
6803/// Fetch a specific instance of an IpAccessControlList
6804pub async fn fetch_sip_ip_access_control_list(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipIpAccessControlList, Error<FetchSipIpAccessControlListError>> {
6805    let local_var_configuration = configuration;
6806
6807    let local_var_client = &local_var_configuration.client;
6808
6809    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6810    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6811
6812    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6813        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6814    }
6815    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6816        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6817    };
6818
6819    let local_var_req = local_var_req_builder.build()?;
6820    let local_var_resp = local_var_client.execute(local_var_req).await?;
6821
6822    let local_var_status = local_var_resp.status();
6823    let local_var_content = local_var_resp.text().await?;
6824
6825    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6826        serde_json::from_str(&local_var_content).map_err(Error::from)
6827    } else {
6828        let local_var_entity: Option<FetchSipIpAccessControlListError> = serde_json::from_str(&local_var_content).ok();
6829        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6830        Err(Error::ResponseError(local_var_error))
6831    }
6832}
6833
6834/// Fetch an IpAccessControlListMapping resource.
6835pub async fn fetch_sip_ip_access_control_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomainPeriodSipIpAccessControlListMapping, Error<FetchSipIpAccessControlListMappingError>> {
6836    let local_var_configuration = configuration;
6837
6838    let local_var_client = &local_var_configuration.client;
6839
6840    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/IpAccessControlListMappings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid), Sid=crate::apis::urlencode(sid));
6841    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6842
6843    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6844        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6845    }
6846    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6847        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6848    };
6849
6850    let local_var_req = local_var_req_builder.build()?;
6851    let local_var_resp = local_var_client.execute(local_var_req).await?;
6852
6853    let local_var_status = local_var_resp.status();
6854    let local_var_content = local_var_resp.text().await?;
6855
6856    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6857        serde_json::from_str(&local_var_content).map_err(Error::from)
6858    } else {
6859        let local_var_entity: Option<FetchSipIpAccessControlListMappingError> = serde_json::from_str(&local_var_content).ok();
6860        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6861        Err(Error::ResponseError(local_var_error))
6862    }
6863}
6864
6865/// Read one IpAddress resource.
6866pub async fn fetch_sip_ip_address(configuration: &configuration::Configuration, account_sid: &str, ip_access_control_list_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipIpAccessControlListPeriodSipIpAddress, Error<FetchSipIpAddressError>> {
6867    let local_var_configuration = configuration;
6868
6869    let local_var_client = &local_var_configuration.client;
6870
6871    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid), Sid=crate::apis::urlencode(sid));
6872    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6873
6874    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6875        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6876    }
6877    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6878        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6879    };
6880
6881    let local_var_req = local_var_req_builder.build()?;
6882    let local_var_resp = local_var_client.execute(local_var_req).await?;
6883
6884    let local_var_status = local_var_resp.status();
6885    let local_var_content = local_var_resp.text().await?;
6886
6887    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6888        serde_json::from_str(&local_var_content).map_err(Error::from)
6889    } else {
6890        let local_var_entity: Option<FetchSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
6891        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6892        Err(Error::ResponseError(local_var_error))
6893    }
6894}
6895
6896/// Fetch an instance of a Transcription
6897pub async fn fetch_transcription(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodTranscription, Error<FetchTranscriptionError>> {
6898    let local_var_configuration = configuration;
6899
6900    let local_var_client = &local_var_configuration.client;
6901
6902    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Transcriptions/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6903    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6904
6905    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6906        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6907    }
6908    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6909        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6910    };
6911
6912    let local_var_req = local_var_req_builder.build()?;
6913    let local_var_resp = local_var_client.execute(local_var_req).await?;
6914
6915    let local_var_status = local_var_resp.status();
6916    let local_var_content = local_var_resp.text().await?;
6917
6918    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6919        serde_json::from_str(&local_var_content).map_err(Error::from)
6920    } else {
6921        let local_var_entity: Option<FetchTranscriptionError> = serde_json::from_str(&local_var_content).ok();
6922        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6923        Err(Error::ResponseError(local_var_error))
6924    }
6925}
6926
6927/// Fetch and instance of a usage-trigger
6928pub async fn fetch_usage_trigger(configuration: &configuration::Configuration, account_sid: &str, sid: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodUsagePeriodUsageTrigger, Error<FetchUsageTriggerError>> {
6929    let local_var_configuration = configuration;
6930
6931    let local_var_client = &local_var_configuration.client;
6932
6933    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Triggers/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
6934    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6935
6936    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6937        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6938    }
6939    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6940        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6941    };
6942
6943    let local_var_req = local_var_req_builder.build()?;
6944    let local_var_resp = local_var_client.execute(local_var_req).await?;
6945
6946    let local_var_status = local_var_resp.status();
6947    let local_var_content = local_var_resp.text().await?;
6948
6949    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6950        serde_json::from_str(&local_var_content).map_err(Error::from)
6951    } else {
6952        let local_var_entity: Option<FetchUsageTriggerError> = serde_json::from_str(&local_var_content).ok();
6953        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6954        Err(Error::ResponseError(local_var_error))
6955    }
6956}
6957
6958/// Retrieves a collection of Accounts belonging to the account used to make the request
6959pub async fn list_account(configuration: &configuration::Configuration, friendly_name: Option<&str>, status: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListAccountResponse, Error<ListAccountError>> {
6960    let local_var_configuration = configuration;
6961
6962    let local_var_client = &local_var_configuration.client;
6963
6964    let local_var_uri_str = format!("{}/2010-04-01/Accounts.json", local_var_configuration.base_path);
6965    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
6966
6967    if let Some(ref local_var_str) = friendly_name {
6968        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
6969    }
6970    if let Some(ref local_var_str) = status {
6971        local_var_req_builder = local_var_req_builder.query(&[("Status", &local_var_str.to_string())]);
6972    }
6973    if let Some(ref local_var_str) = page_size {
6974        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
6975    }
6976    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
6977        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
6978    }
6979    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
6980        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
6981    };
6982
6983    let local_var_req = local_var_req_builder.build()?;
6984    let local_var_resp = local_var_client.execute(local_var_req).await?;
6985
6986    let local_var_status = local_var_resp.status();
6987    let local_var_content = local_var_resp.text().await?;
6988
6989    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
6990        serde_json::from_str(&local_var_content).map_err(Error::from)
6991    } else {
6992        let local_var_entity: Option<ListAccountError> = serde_json::from_str(&local_var_content).ok();
6993        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
6994        Err(Error::ResponseError(local_var_error))
6995    }
6996}
6997
6998/// 
6999pub async fn list_address(configuration: &configuration::Configuration, account_sid: &str, customer_name: Option<&str>, friendly_name: Option<&str>, iso_country: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListAddressResponse, Error<ListAddressError>> {
7000    let local_var_configuration = configuration;
7001
7002    let local_var_client = &local_var_configuration.client;
7003
7004    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Addresses.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
7005    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7006
7007    if let Some(ref local_var_str) = customer_name {
7008        local_var_req_builder = local_var_req_builder.query(&[("CustomerName", &local_var_str.to_string())]);
7009    }
7010    if let Some(ref local_var_str) = friendly_name {
7011        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
7012    }
7013    if let Some(ref local_var_str) = iso_country {
7014        local_var_req_builder = local_var_req_builder.query(&[("IsoCountry", &local_var_str.to_string())]);
7015    }
7016    if let Some(ref local_var_str) = page_size {
7017        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7018    }
7019    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7020        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7021    }
7022    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7023        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7024    };
7025
7026    let local_var_req = local_var_req_builder.build()?;
7027    let local_var_resp = local_var_client.execute(local_var_req).await?;
7028
7029    let local_var_status = local_var_resp.status();
7030    let local_var_content = local_var_resp.text().await?;
7031
7032    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7033        serde_json::from_str(&local_var_content).map_err(Error::from)
7034    } else {
7035        let local_var_entity: Option<ListAddressError> = serde_json::from_str(&local_var_content).ok();
7036        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7037        Err(Error::ResponseError(local_var_error))
7038    }
7039}
7040
7041/// Retrieve a list of applications representing an application within the requesting account
7042pub async fn list_application(configuration: &configuration::Configuration, account_sid: &str, friendly_name: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListApplicationResponse, Error<ListApplicationError>> {
7043    let local_var_configuration = configuration;
7044
7045    let local_var_client = &local_var_configuration.client;
7046
7047    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
7048    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7049
7050    if let Some(ref local_var_str) = friendly_name {
7051        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
7052    }
7053    if let Some(ref local_var_str) = page_size {
7054        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7055    }
7056    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7057        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7058    }
7059    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7060        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7061    };
7062
7063    let local_var_req = local_var_req_builder.build()?;
7064    let local_var_resp = local_var_client.execute(local_var_req).await?;
7065
7066    let local_var_status = local_var_resp.status();
7067    let local_var_content = local_var_resp.text().await?;
7068
7069    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7070        serde_json::from_str(&local_var_content).map_err(Error::from)
7071    } else {
7072        let local_var_entity: Option<ListApplicationError> = serde_json::from_str(&local_var_content).ok();
7073        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7074        Err(Error::ResponseError(local_var_error))
7075    }
7076}
7077
7078/// Retrieve a list of authorized-connect-apps belonging to the account used to make the request
7079pub async fn list_authorized_connect_app(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListAuthorizedConnectAppResponse, Error<ListAuthorizedConnectAppError>> {
7080    let local_var_configuration = configuration;
7081
7082    let local_var_client = &local_var_configuration.client;
7083
7084    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AuthorizedConnectApps.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
7085    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7086
7087    if let Some(ref local_var_str) = page_size {
7088        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7089    }
7090    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7091        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7092    }
7093    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7094        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7095    };
7096
7097    let local_var_req = local_var_req_builder.build()?;
7098    let local_var_resp = local_var_client.execute(local_var_req).await?;
7099
7100    let local_var_status = local_var_resp.status();
7101    let local_var_content = local_var_resp.text().await?;
7102
7103    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7104        serde_json::from_str(&local_var_content).map_err(Error::from)
7105    } else {
7106        let local_var_entity: Option<ListAuthorizedConnectAppError> = serde_json::from_str(&local_var_content).ok();
7107        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7108        Err(Error::ResponseError(local_var_error))
7109    }
7110}
7111
7112/// 
7113pub async fn list_available_phone_number_country(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListAvailablePhoneNumberCountryResponse, Error<ListAvailablePhoneNumberCountryError>> {
7114    let local_var_configuration = configuration;
7115
7116    let local_var_client = &local_var_configuration.client;
7117
7118    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AvailablePhoneNumbers.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
7119    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7120
7121    if let Some(ref local_var_str) = page_size {
7122        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7123    }
7124    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7125        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7126    }
7127    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7128        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7129    };
7130
7131    let local_var_req = local_var_req_builder.build()?;
7132    let local_var_resp = local_var_client.execute(local_var_req).await?;
7133
7134    let local_var_status = local_var_resp.status();
7135    let local_var_content = local_var_resp.text().await?;
7136
7137    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7138        serde_json::from_str(&local_var_content).map_err(Error::from)
7139    } else {
7140        let local_var_entity: Option<ListAvailablePhoneNumberCountryError> = serde_json::from_str(&local_var_content).ok();
7141        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7142        Err(Error::ResponseError(local_var_error))
7143    }
7144}
7145
7146/// 
7147pub async fn list_available_phone_number_local(configuration: &configuration::Configuration, account_sid: &str, country_code: &str, area_code: Option<i32>, contains: Option<&str>, sms_enabled: Option<bool>, mms_enabled: Option<bool>, voice_enabled: Option<bool>, exclude_all_address_required: Option<bool>, exclude_local_address_required: Option<bool>, exclude_foreign_address_required: Option<bool>, beta: Option<bool>, near_number: Option<&str>, near_lat_long: Option<&str>, distance: Option<i32>, in_postal_code: Option<&str>, in_region: Option<&str>, in_rate_center: Option<&str>, in_lata: Option<&str>, in_locality: Option<&str>, fax_enabled: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListAvailablePhoneNumberLocalResponse, Error<ListAvailablePhoneNumberLocalError>> {
7148    let local_var_configuration = configuration;
7149
7150    let local_var_client = &local_var_configuration.client;
7151
7152    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AvailablePhoneNumbers/{CountryCode}/Local.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CountryCode=crate::apis::urlencode(country_code));
7153    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7154
7155    if let Some(ref local_var_str) = area_code {
7156        local_var_req_builder = local_var_req_builder.query(&[("AreaCode", &local_var_str.to_string())]);
7157    }
7158    if let Some(ref local_var_str) = contains {
7159        local_var_req_builder = local_var_req_builder.query(&[("Contains", &local_var_str.to_string())]);
7160    }
7161    if let Some(ref local_var_str) = sms_enabled {
7162        local_var_req_builder = local_var_req_builder.query(&[("SmsEnabled", &local_var_str.to_string())]);
7163    }
7164    if let Some(ref local_var_str) = mms_enabled {
7165        local_var_req_builder = local_var_req_builder.query(&[("MmsEnabled", &local_var_str.to_string())]);
7166    }
7167    if let Some(ref local_var_str) = voice_enabled {
7168        local_var_req_builder = local_var_req_builder.query(&[("VoiceEnabled", &local_var_str.to_string())]);
7169    }
7170    if let Some(ref local_var_str) = exclude_all_address_required {
7171        local_var_req_builder = local_var_req_builder.query(&[("ExcludeAllAddressRequired", &local_var_str.to_string())]);
7172    }
7173    if let Some(ref local_var_str) = exclude_local_address_required {
7174        local_var_req_builder = local_var_req_builder.query(&[("ExcludeLocalAddressRequired", &local_var_str.to_string())]);
7175    }
7176    if let Some(ref local_var_str) = exclude_foreign_address_required {
7177        local_var_req_builder = local_var_req_builder.query(&[("ExcludeForeignAddressRequired", &local_var_str.to_string())]);
7178    }
7179    if let Some(ref local_var_str) = beta {
7180        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
7181    }
7182    if let Some(ref local_var_str) = near_number {
7183        local_var_req_builder = local_var_req_builder.query(&[("NearNumber", &local_var_str.to_string())]);
7184    }
7185    if let Some(ref local_var_str) = near_lat_long {
7186        local_var_req_builder = local_var_req_builder.query(&[("NearLatLong", &local_var_str.to_string())]);
7187    }
7188    if let Some(ref local_var_str) = distance {
7189        local_var_req_builder = local_var_req_builder.query(&[("Distance", &local_var_str.to_string())]);
7190    }
7191    if let Some(ref local_var_str) = in_postal_code {
7192        local_var_req_builder = local_var_req_builder.query(&[("InPostalCode", &local_var_str.to_string())]);
7193    }
7194    if let Some(ref local_var_str) = in_region {
7195        local_var_req_builder = local_var_req_builder.query(&[("InRegion", &local_var_str.to_string())]);
7196    }
7197    if let Some(ref local_var_str) = in_rate_center {
7198        local_var_req_builder = local_var_req_builder.query(&[("InRateCenter", &local_var_str.to_string())]);
7199    }
7200    if let Some(ref local_var_str) = in_lata {
7201        local_var_req_builder = local_var_req_builder.query(&[("InLata", &local_var_str.to_string())]);
7202    }
7203    if let Some(ref local_var_str) = in_locality {
7204        local_var_req_builder = local_var_req_builder.query(&[("InLocality", &local_var_str.to_string())]);
7205    }
7206    if let Some(ref local_var_str) = fax_enabled {
7207        local_var_req_builder = local_var_req_builder.query(&[("FaxEnabled", &local_var_str.to_string())]);
7208    }
7209    if let Some(ref local_var_str) = page_size {
7210        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7211    }
7212    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7213        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7214    }
7215    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7216        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7217    };
7218
7219    let local_var_req = local_var_req_builder.build()?;
7220    let local_var_resp = local_var_client.execute(local_var_req).await?;
7221
7222    let local_var_status = local_var_resp.status();
7223    let local_var_content = local_var_resp.text().await?;
7224
7225    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7226        serde_json::from_str(&local_var_content).map_err(Error::from)
7227    } else {
7228        let local_var_entity: Option<ListAvailablePhoneNumberLocalError> = serde_json::from_str(&local_var_content).ok();
7229        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7230        Err(Error::ResponseError(local_var_error))
7231    }
7232}
7233
7234/// 
7235pub async fn list_available_phone_number_machine_to_machine(configuration: &configuration::Configuration, account_sid: &str, country_code: &str, area_code: Option<i32>, contains: Option<&str>, sms_enabled: Option<bool>, mms_enabled: Option<bool>, voice_enabled: Option<bool>, exclude_all_address_required: Option<bool>, exclude_local_address_required: Option<bool>, exclude_foreign_address_required: Option<bool>, beta: Option<bool>, near_number: Option<&str>, near_lat_long: Option<&str>, distance: Option<i32>, in_postal_code: Option<&str>, in_region: Option<&str>, in_rate_center: Option<&str>, in_lata: Option<&str>, in_locality: Option<&str>, fax_enabled: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListAvailablePhoneNumberMachineToMachineResponse, Error<ListAvailablePhoneNumberMachineToMachineError>> {
7236    let local_var_configuration = configuration;
7237
7238    let local_var_client = &local_var_configuration.client;
7239
7240    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AvailablePhoneNumbers/{CountryCode}/MachineToMachine.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CountryCode=crate::apis::urlencode(country_code));
7241    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7242
7243    if let Some(ref local_var_str) = area_code {
7244        local_var_req_builder = local_var_req_builder.query(&[("AreaCode", &local_var_str.to_string())]);
7245    }
7246    if let Some(ref local_var_str) = contains {
7247        local_var_req_builder = local_var_req_builder.query(&[("Contains", &local_var_str.to_string())]);
7248    }
7249    if let Some(ref local_var_str) = sms_enabled {
7250        local_var_req_builder = local_var_req_builder.query(&[("SmsEnabled", &local_var_str.to_string())]);
7251    }
7252    if let Some(ref local_var_str) = mms_enabled {
7253        local_var_req_builder = local_var_req_builder.query(&[("MmsEnabled", &local_var_str.to_string())]);
7254    }
7255    if let Some(ref local_var_str) = voice_enabled {
7256        local_var_req_builder = local_var_req_builder.query(&[("VoiceEnabled", &local_var_str.to_string())]);
7257    }
7258    if let Some(ref local_var_str) = exclude_all_address_required {
7259        local_var_req_builder = local_var_req_builder.query(&[("ExcludeAllAddressRequired", &local_var_str.to_string())]);
7260    }
7261    if let Some(ref local_var_str) = exclude_local_address_required {
7262        local_var_req_builder = local_var_req_builder.query(&[("ExcludeLocalAddressRequired", &local_var_str.to_string())]);
7263    }
7264    if let Some(ref local_var_str) = exclude_foreign_address_required {
7265        local_var_req_builder = local_var_req_builder.query(&[("ExcludeForeignAddressRequired", &local_var_str.to_string())]);
7266    }
7267    if let Some(ref local_var_str) = beta {
7268        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
7269    }
7270    if let Some(ref local_var_str) = near_number {
7271        local_var_req_builder = local_var_req_builder.query(&[("NearNumber", &local_var_str.to_string())]);
7272    }
7273    if let Some(ref local_var_str) = near_lat_long {
7274        local_var_req_builder = local_var_req_builder.query(&[("NearLatLong", &local_var_str.to_string())]);
7275    }
7276    if let Some(ref local_var_str) = distance {
7277        local_var_req_builder = local_var_req_builder.query(&[("Distance", &local_var_str.to_string())]);
7278    }
7279    if let Some(ref local_var_str) = in_postal_code {
7280        local_var_req_builder = local_var_req_builder.query(&[("InPostalCode", &local_var_str.to_string())]);
7281    }
7282    if let Some(ref local_var_str) = in_region {
7283        local_var_req_builder = local_var_req_builder.query(&[("InRegion", &local_var_str.to_string())]);
7284    }
7285    if let Some(ref local_var_str) = in_rate_center {
7286        local_var_req_builder = local_var_req_builder.query(&[("InRateCenter", &local_var_str.to_string())]);
7287    }
7288    if let Some(ref local_var_str) = in_lata {
7289        local_var_req_builder = local_var_req_builder.query(&[("InLata", &local_var_str.to_string())]);
7290    }
7291    if let Some(ref local_var_str) = in_locality {
7292        local_var_req_builder = local_var_req_builder.query(&[("InLocality", &local_var_str.to_string())]);
7293    }
7294    if let Some(ref local_var_str) = fax_enabled {
7295        local_var_req_builder = local_var_req_builder.query(&[("FaxEnabled", &local_var_str.to_string())]);
7296    }
7297    if let Some(ref local_var_str) = page_size {
7298        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7299    }
7300    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7301        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7302    }
7303    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7304        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7305    };
7306
7307    let local_var_req = local_var_req_builder.build()?;
7308    let local_var_resp = local_var_client.execute(local_var_req).await?;
7309
7310    let local_var_status = local_var_resp.status();
7311    let local_var_content = local_var_resp.text().await?;
7312
7313    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7314        serde_json::from_str(&local_var_content).map_err(Error::from)
7315    } else {
7316        let local_var_entity: Option<ListAvailablePhoneNumberMachineToMachineError> = serde_json::from_str(&local_var_content).ok();
7317        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7318        Err(Error::ResponseError(local_var_error))
7319    }
7320}
7321
7322/// 
7323pub async fn list_available_phone_number_mobile(configuration: &configuration::Configuration, account_sid: &str, country_code: &str, area_code: Option<i32>, contains: Option<&str>, sms_enabled: Option<bool>, mms_enabled: Option<bool>, voice_enabled: Option<bool>, exclude_all_address_required: Option<bool>, exclude_local_address_required: Option<bool>, exclude_foreign_address_required: Option<bool>, beta: Option<bool>, near_number: Option<&str>, near_lat_long: Option<&str>, distance: Option<i32>, in_postal_code: Option<&str>, in_region: Option<&str>, in_rate_center: Option<&str>, in_lata: Option<&str>, in_locality: Option<&str>, fax_enabled: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListAvailablePhoneNumberMobileResponse, Error<ListAvailablePhoneNumberMobileError>> {
7324    let local_var_configuration = configuration;
7325
7326    let local_var_client = &local_var_configuration.client;
7327
7328    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AvailablePhoneNumbers/{CountryCode}/Mobile.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CountryCode=crate::apis::urlencode(country_code));
7329    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7330
7331    if let Some(ref local_var_str) = area_code {
7332        local_var_req_builder = local_var_req_builder.query(&[("AreaCode", &local_var_str.to_string())]);
7333    }
7334    if let Some(ref local_var_str) = contains {
7335        local_var_req_builder = local_var_req_builder.query(&[("Contains", &local_var_str.to_string())]);
7336    }
7337    if let Some(ref local_var_str) = sms_enabled {
7338        local_var_req_builder = local_var_req_builder.query(&[("SmsEnabled", &local_var_str.to_string())]);
7339    }
7340    if let Some(ref local_var_str) = mms_enabled {
7341        local_var_req_builder = local_var_req_builder.query(&[("MmsEnabled", &local_var_str.to_string())]);
7342    }
7343    if let Some(ref local_var_str) = voice_enabled {
7344        local_var_req_builder = local_var_req_builder.query(&[("VoiceEnabled", &local_var_str.to_string())]);
7345    }
7346    if let Some(ref local_var_str) = exclude_all_address_required {
7347        local_var_req_builder = local_var_req_builder.query(&[("ExcludeAllAddressRequired", &local_var_str.to_string())]);
7348    }
7349    if let Some(ref local_var_str) = exclude_local_address_required {
7350        local_var_req_builder = local_var_req_builder.query(&[("ExcludeLocalAddressRequired", &local_var_str.to_string())]);
7351    }
7352    if let Some(ref local_var_str) = exclude_foreign_address_required {
7353        local_var_req_builder = local_var_req_builder.query(&[("ExcludeForeignAddressRequired", &local_var_str.to_string())]);
7354    }
7355    if let Some(ref local_var_str) = beta {
7356        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
7357    }
7358    if let Some(ref local_var_str) = near_number {
7359        local_var_req_builder = local_var_req_builder.query(&[("NearNumber", &local_var_str.to_string())]);
7360    }
7361    if let Some(ref local_var_str) = near_lat_long {
7362        local_var_req_builder = local_var_req_builder.query(&[("NearLatLong", &local_var_str.to_string())]);
7363    }
7364    if let Some(ref local_var_str) = distance {
7365        local_var_req_builder = local_var_req_builder.query(&[("Distance", &local_var_str.to_string())]);
7366    }
7367    if let Some(ref local_var_str) = in_postal_code {
7368        local_var_req_builder = local_var_req_builder.query(&[("InPostalCode", &local_var_str.to_string())]);
7369    }
7370    if let Some(ref local_var_str) = in_region {
7371        local_var_req_builder = local_var_req_builder.query(&[("InRegion", &local_var_str.to_string())]);
7372    }
7373    if let Some(ref local_var_str) = in_rate_center {
7374        local_var_req_builder = local_var_req_builder.query(&[("InRateCenter", &local_var_str.to_string())]);
7375    }
7376    if let Some(ref local_var_str) = in_lata {
7377        local_var_req_builder = local_var_req_builder.query(&[("InLata", &local_var_str.to_string())]);
7378    }
7379    if let Some(ref local_var_str) = in_locality {
7380        local_var_req_builder = local_var_req_builder.query(&[("InLocality", &local_var_str.to_string())]);
7381    }
7382    if let Some(ref local_var_str) = fax_enabled {
7383        local_var_req_builder = local_var_req_builder.query(&[("FaxEnabled", &local_var_str.to_string())]);
7384    }
7385    if let Some(ref local_var_str) = page_size {
7386        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7387    }
7388    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7389        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7390    }
7391    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7392        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7393    };
7394
7395    let local_var_req = local_var_req_builder.build()?;
7396    let local_var_resp = local_var_client.execute(local_var_req).await?;
7397
7398    let local_var_status = local_var_resp.status();
7399    let local_var_content = local_var_resp.text().await?;
7400
7401    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7402        serde_json::from_str(&local_var_content).map_err(Error::from)
7403    } else {
7404        let local_var_entity: Option<ListAvailablePhoneNumberMobileError> = serde_json::from_str(&local_var_content).ok();
7405        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7406        Err(Error::ResponseError(local_var_error))
7407    }
7408}
7409
7410/// 
7411pub async fn list_available_phone_number_national(configuration: &configuration::Configuration, account_sid: &str, country_code: &str, area_code: Option<i32>, contains: Option<&str>, sms_enabled: Option<bool>, mms_enabled: Option<bool>, voice_enabled: Option<bool>, exclude_all_address_required: Option<bool>, exclude_local_address_required: Option<bool>, exclude_foreign_address_required: Option<bool>, beta: Option<bool>, near_number: Option<&str>, near_lat_long: Option<&str>, distance: Option<i32>, in_postal_code: Option<&str>, in_region: Option<&str>, in_rate_center: Option<&str>, in_lata: Option<&str>, in_locality: Option<&str>, fax_enabled: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListAvailablePhoneNumberNationalResponse, Error<ListAvailablePhoneNumberNationalError>> {
7412    let local_var_configuration = configuration;
7413
7414    let local_var_client = &local_var_configuration.client;
7415
7416    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AvailablePhoneNumbers/{CountryCode}/National.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CountryCode=crate::apis::urlencode(country_code));
7417    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7418
7419    if let Some(ref local_var_str) = area_code {
7420        local_var_req_builder = local_var_req_builder.query(&[("AreaCode", &local_var_str.to_string())]);
7421    }
7422    if let Some(ref local_var_str) = contains {
7423        local_var_req_builder = local_var_req_builder.query(&[("Contains", &local_var_str.to_string())]);
7424    }
7425    if let Some(ref local_var_str) = sms_enabled {
7426        local_var_req_builder = local_var_req_builder.query(&[("SmsEnabled", &local_var_str.to_string())]);
7427    }
7428    if let Some(ref local_var_str) = mms_enabled {
7429        local_var_req_builder = local_var_req_builder.query(&[("MmsEnabled", &local_var_str.to_string())]);
7430    }
7431    if let Some(ref local_var_str) = voice_enabled {
7432        local_var_req_builder = local_var_req_builder.query(&[("VoiceEnabled", &local_var_str.to_string())]);
7433    }
7434    if let Some(ref local_var_str) = exclude_all_address_required {
7435        local_var_req_builder = local_var_req_builder.query(&[("ExcludeAllAddressRequired", &local_var_str.to_string())]);
7436    }
7437    if let Some(ref local_var_str) = exclude_local_address_required {
7438        local_var_req_builder = local_var_req_builder.query(&[("ExcludeLocalAddressRequired", &local_var_str.to_string())]);
7439    }
7440    if let Some(ref local_var_str) = exclude_foreign_address_required {
7441        local_var_req_builder = local_var_req_builder.query(&[("ExcludeForeignAddressRequired", &local_var_str.to_string())]);
7442    }
7443    if let Some(ref local_var_str) = beta {
7444        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
7445    }
7446    if let Some(ref local_var_str) = near_number {
7447        local_var_req_builder = local_var_req_builder.query(&[("NearNumber", &local_var_str.to_string())]);
7448    }
7449    if let Some(ref local_var_str) = near_lat_long {
7450        local_var_req_builder = local_var_req_builder.query(&[("NearLatLong", &local_var_str.to_string())]);
7451    }
7452    if let Some(ref local_var_str) = distance {
7453        local_var_req_builder = local_var_req_builder.query(&[("Distance", &local_var_str.to_string())]);
7454    }
7455    if let Some(ref local_var_str) = in_postal_code {
7456        local_var_req_builder = local_var_req_builder.query(&[("InPostalCode", &local_var_str.to_string())]);
7457    }
7458    if let Some(ref local_var_str) = in_region {
7459        local_var_req_builder = local_var_req_builder.query(&[("InRegion", &local_var_str.to_string())]);
7460    }
7461    if let Some(ref local_var_str) = in_rate_center {
7462        local_var_req_builder = local_var_req_builder.query(&[("InRateCenter", &local_var_str.to_string())]);
7463    }
7464    if let Some(ref local_var_str) = in_lata {
7465        local_var_req_builder = local_var_req_builder.query(&[("InLata", &local_var_str.to_string())]);
7466    }
7467    if let Some(ref local_var_str) = in_locality {
7468        local_var_req_builder = local_var_req_builder.query(&[("InLocality", &local_var_str.to_string())]);
7469    }
7470    if let Some(ref local_var_str) = fax_enabled {
7471        local_var_req_builder = local_var_req_builder.query(&[("FaxEnabled", &local_var_str.to_string())]);
7472    }
7473    if let Some(ref local_var_str) = page_size {
7474        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7475    }
7476    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7477        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7478    }
7479    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7480        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7481    };
7482
7483    let local_var_req = local_var_req_builder.build()?;
7484    let local_var_resp = local_var_client.execute(local_var_req).await?;
7485
7486    let local_var_status = local_var_resp.status();
7487    let local_var_content = local_var_resp.text().await?;
7488
7489    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7490        serde_json::from_str(&local_var_content).map_err(Error::from)
7491    } else {
7492        let local_var_entity: Option<ListAvailablePhoneNumberNationalError> = serde_json::from_str(&local_var_content).ok();
7493        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7494        Err(Error::ResponseError(local_var_error))
7495    }
7496}
7497
7498/// 
7499pub async fn list_available_phone_number_shared_cost(configuration: &configuration::Configuration, account_sid: &str, country_code: &str, area_code: Option<i32>, contains: Option<&str>, sms_enabled: Option<bool>, mms_enabled: Option<bool>, voice_enabled: Option<bool>, exclude_all_address_required: Option<bool>, exclude_local_address_required: Option<bool>, exclude_foreign_address_required: Option<bool>, beta: Option<bool>, near_number: Option<&str>, near_lat_long: Option<&str>, distance: Option<i32>, in_postal_code: Option<&str>, in_region: Option<&str>, in_rate_center: Option<&str>, in_lata: Option<&str>, in_locality: Option<&str>, fax_enabled: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListAvailablePhoneNumberSharedCostResponse, Error<ListAvailablePhoneNumberSharedCostError>> {
7500    let local_var_configuration = configuration;
7501
7502    let local_var_client = &local_var_configuration.client;
7503
7504    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AvailablePhoneNumbers/{CountryCode}/SharedCost.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CountryCode=crate::apis::urlencode(country_code));
7505    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7506
7507    if let Some(ref local_var_str) = area_code {
7508        local_var_req_builder = local_var_req_builder.query(&[("AreaCode", &local_var_str.to_string())]);
7509    }
7510    if let Some(ref local_var_str) = contains {
7511        local_var_req_builder = local_var_req_builder.query(&[("Contains", &local_var_str.to_string())]);
7512    }
7513    if let Some(ref local_var_str) = sms_enabled {
7514        local_var_req_builder = local_var_req_builder.query(&[("SmsEnabled", &local_var_str.to_string())]);
7515    }
7516    if let Some(ref local_var_str) = mms_enabled {
7517        local_var_req_builder = local_var_req_builder.query(&[("MmsEnabled", &local_var_str.to_string())]);
7518    }
7519    if let Some(ref local_var_str) = voice_enabled {
7520        local_var_req_builder = local_var_req_builder.query(&[("VoiceEnabled", &local_var_str.to_string())]);
7521    }
7522    if let Some(ref local_var_str) = exclude_all_address_required {
7523        local_var_req_builder = local_var_req_builder.query(&[("ExcludeAllAddressRequired", &local_var_str.to_string())]);
7524    }
7525    if let Some(ref local_var_str) = exclude_local_address_required {
7526        local_var_req_builder = local_var_req_builder.query(&[("ExcludeLocalAddressRequired", &local_var_str.to_string())]);
7527    }
7528    if let Some(ref local_var_str) = exclude_foreign_address_required {
7529        local_var_req_builder = local_var_req_builder.query(&[("ExcludeForeignAddressRequired", &local_var_str.to_string())]);
7530    }
7531    if let Some(ref local_var_str) = beta {
7532        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
7533    }
7534    if let Some(ref local_var_str) = near_number {
7535        local_var_req_builder = local_var_req_builder.query(&[("NearNumber", &local_var_str.to_string())]);
7536    }
7537    if let Some(ref local_var_str) = near_lat_long {
7538        local_var_req_builder = local_var_req_builder.query(&[("NearLatLong", &local_var_str.to_string())]);
7539    }
7540    if let Some(ref local_var_str) = distance {
7541        local_var_req_builder = local_var_req_builder.query(&[("Distance", &local_var_str.to_string())]);
7542    }
7543    if let Some(ref local_var_str) = in_postal_code {
7544        local_var_req_builder = local_var_req_builder.query(&[("InPostalCode", &local_var_str.to_string())]);
7545    }
7546    if let Some(ref local_var_str) = in_region {
7547        local_var_req_builder = local_var_req_builder.query(&[("InRegion", &local_var_str.to_string())]);
7548    }
7549    if let Some(ref local_var_str) = in_rate_center {
7550        local_var_req_builder = local_var_req_builder.query(&[("InRateCenter", &local_var_str.to_string())]);
7551    }
7552    if let Some(ref local_var_str) = in_lata {
7553        local_var_req_builder = local_var_req_builder.query(&[("InLata", &local_var_str.to_string())]);
7554    }
7555    if let Some(ref local_var_str) = in_locality {
7556        local_var_req_builder = local_var_req_builder.query(&[("InLocality", &local_var_str.to_string())]);
7557    }
7558    if let Some(ref local_var_str) = fax_enabled {
7559        local_var_req_builder = local_var_req_builder.query(&[("FaxEnabled", &local_var_str.to_string())]);
7560    }
7561    if let Some(ref local_var_str) = page_size {
7562        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7563    }
7564    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7565        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7566    }
7567    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7568        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7569    };
7570
7571    let local_var_req = local_var_req_builder.build()?;
7572    let local_var_resp = local_var_client.execute(local_var_req).await?;
7573
7574    let local_var_status = local_var_resp.status();
7575    let local_var_content = local_var_resp.text().await?;
7576
7577    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7578        serde_json::from_str(&local_var_content).map_err(Error::from)
7579    } else {
7580        let local_var_entity: Option<ListAvailablePhoneNumberSharedCostError> = serde_json::from_str(&local_var_content).ok();
7581        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7582        Err(Error::ResponseError(local_var_error))
7583    }
7584}
7585
7586/// 
7587pub async fn list_available_phone_number_toll_free(configuration: &configuration::Configuration, account_sid: &str, country_code: &str, area_code: Option<i32>, contains: Option<&str>, sms_enabled: Option<bool>, mms_enabled: Option<bool>, voice_enabled: Option<bool>, exclude_all_address_required: Option<bool>, exclude_local_address_required: Option<bool>, exclude_foreign_address_required: Option<bool>, beta: Option<bool>, near_number: Option<&str>, near_lat_long: Option<&str>, distance: Option<i32>, in_postal_code: Option<&str>, in_region: Option<&str>, in_rate_center: Option<&str>, in_lata: Option<&str>, in_locality: Option<&str>, fax_enabled: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListAvailablePhoneNumberTollFreeResponse, Error<ListAvailablePhoneNumberTollFreeError>> {
7588    let local_var_configuration = configuration;
7589
7590    let local_var_client = &local_var_configuration.client;
7591
7592    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AvailablePhoneNumbers/{CountryCode}/TollFree.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CountryCode=crate::apis::urlencode(country_code));
7593    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7594
7595    if let Some(ref local_var_str) = area_code {
7596        local_var_req_builder = local_var_req_builder.query(&[("AreaCode", &local_var_str.to_string())]);
7597    }
7598    if let Some(ref local_var_str) = contains {
7599        local_var_req_builder = local_var_req_builder.query(&[("Contains", &local_var_str.to_string())]);
7600    }
7601    if let Some(ref local_var_str) = sms_enabled {
7602        local_var_req_builder = local_var_req_builder.query(&[("SmsEnabled", &local_var_str.to_string())]);
7603    }
7604    if let Some(ref local_var_str) = mms_enabled {
7605        local_var_req_builder = local_var_req_builder.query(&[("MmsEnabled", &local_var_str.to_string())]);
7606    }
7607    if let Some(ref local_var_str) = voice_enabled {
7608        local_var_req_builder = local_var_req_builder.query(&[("VoiceEnabled", &local_var_str.to_string())]);
7609    }
7610    if let Some(ref local_var_str) = exclude_all_address_required {
7611        local_var_req_builder = local_var_req_builder.query(&[("ExcludeAllAddressRequired", &local_var_str.to_string())]);
7612    }
7613    if let Some(ref local_var_str) = exclude_local_address_required {
7614        local_var_req_builder = local_var_req_builder.query(&[("ExcludeLocalAddressRequired", &local_var_str.to_string())]);
7615    }
7616    if let Some(ref local_var_str) = exclude_foreign_address_required {
7617        local_var_req_builder = local_var_req_builder.query(&[("ExcludeForeignAddressRequired", &local_var_str.to_string())]);
7618    }
7619    if let Some(ref local_var_str) = beta {
7620        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
7621    }
7622    if let Some(ref local_var_str) = near_number {
7623        local_var_req_builder = local_var_req_builder.query(&[("NearNumber", &local_var_str.to_string())]);
7624    }
7625    if let Some(ref local_var_str) = near_lat_long {
7626        local_var_req_builder = local_var_req_builder.query(&[("NearLatLong", &local_var_str.to_string())]);
7627    }
7628    if let Some(ref local_var_str) = distance {
7629        local_var_req_builder = local_var_req_builder.query(&[("Distance", &local_var_str.to_string())]);
7630    }
7631    if let Some(ref local_var_str) = in_postal_code {
7632        local_var_req_builder = local_var_req_builder.query(&[("InPostalCode", &local_var_str.to_string())]);
7633    }
7634    if let Some(ref local_var_str) = in_region {
7635        local_var_req_builder = local_var_req_builder.query(&[("InRegion", &local_var_str.to_string())]);
7636    }
7637    if let Some(ref local_var_str) = in_rate_center {
7638        local_var_req_builder = local_var_req_builder.query(&[("InRateCenter", &local_var_str.to_string())]);
7639    }
7640    if let Some(ref local_var_str) = in_lata {
7641        local_var_req_builder = local_var_req_builder.query(&[("InLata", &local_var_str.to_string())]);
7642    }
7643    if let Some(ref local_var_str) = in_locality {
7644        local_var_req_builder = local_var_req_builder.query(&[("InLocality", &local_var_str.to_string())]);
7645    }
7646    if let Some(ref local_var_str) = fax_enabled {
7647        local_var_req_builder = local_var_req_builder.query(&[("FaxEnabled", &local_var_str.to_string())]);
7648    }
7649    if let Some(ref local_var_str) = page_size {
7650        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7651    }
7652    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7653        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7654    }
7655    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7656        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7657    };
7658
7659    let local_var_req = local_var_req_builder.build()?;
7660    let local_var_resp = local_var_client.execute(local_var_req).await?;
7661
7662    let local_var_status = local_var_resp.status();
7663    let local_var_content = local_var_resp.text().await?;
7664
7665    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7666        serde_json::from_str(&local_var_content).map_err(Error::from)
7667    } else {
7668        let local_var_entity: Option<ListAvailablePhoneNumberTollFreeError> = serde_json::from_str(&local_var_content).ok();
7669        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7670        Err(Error::ResponseError(local_var_error))
7671    }
7672}
7673
7674/// 
7675pub async fn list_available_phone_number_voip(configuration: &configuration::Configuration, account_sid: &str, country_code: &str, area_code: Option<i32>, contains: Option<&str>, sms_enabled: Option<bool>, mms_enabled: Option<bool>, voice_enabled: Option<bool>, exclude_all_address_required: Option<bool>, exclude_local_address_required: Option<bool>, exclude_foreign_address_required: Option<bool>, beta: Option<bool>, near_number: Option<&str>, near_lat_long: Option<&str>, distance: Option<i32>, in_postal_code: Option<&str>, in_region: Option<&str>, in_rate_center: Option<&str>, in_lata: Option<&str>, in_locality: Option<&str>, fax_enabled: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListAvailablePhoneNumberVoipResponse, Error<ListAvailablePhoneNumberVoipError>> {
7676    let local_var_configuration = configuration;
7677
7678    let local_var_client = &local_var_configuration.client;
7679
7680    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/AvailablePhoneNumbers/{CountryCode}/Voip.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CountryCode=crate::apis::urlencode(country_code));
7681    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7682
7683    if let Some(ref local_var_str) = area_code {
7684        local_var_req_builder = local_var_req_builder.query(&[("AreaCode", &local_var_str.to_string())]);
7685    }
7686    if let Some(ref local_var_str) = contains {
7687        local_var_req_builder = local_var_req_builder.query(&[("Contains", &local_var_str.to_string())]);
7688    }
7689    if let Some(ref local_var_str) = sms_enabled {
7690        local_var_req_builder = local_var_req_builder.query(&[("SmsEnabled", &local_var_str.to_string())]);
7691    }
7692    if let Some(ref local_var_str) = mms_enabled {
7693        local_var_req_builder = local_var_req_builder.query(&[("MmsEnabled", &local_var_str.to_string())]);
7694    }
7695    if let Some(ref local_var_str) = voice_enabled {
7696        local_var_req_builder = local_var_req_builder.query(&[("VoiceEnabled", &local_var_str.to_string())]);
7697    }
7698    if let Some(ref local_var_str) = exclude_all_address_required {
7699        local_var_req_builder = local_var_req_builder.query(&[("ExcludeAllAddressRequired", &local_var_str.to_string())]);
7700    }
7701    if let Some(ref local_var_str) = exclude_local_address_required {
7702        local_var_req_builder = local_var_req_builder.query(&[("ExcludeLocalAddressRequired", &local_var_str.to_string())]);
7703    }
7704    if let Some(ref local_var_str) = exclude_foreign_address_required {
7705        local_var_req_builder = local_var_req_builder.query(&[("ExcludeForeignAddressRequired", &local_var_str.to_string())]);
7706    }
7707    if let Some(ref local_var_str) = beta {
7708        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
7709    }
7710    if let Some(ref local_var_str) = near_number {
7711        local_var_req_builder = local_var_req_builder.query(&[("NearNumber", &local_var_str.to_string())]);
7712    }
7713    if let Some(ref local_var_str) = near_lat_long {
7714        local_var_req_builder = local_var_req_builder.query(&[("NearLatLong", &local_var_str.to_string())]);
7715    }
7716    if let Some(ref local_var_str) = distance {
7717        local_var_req_builder = local_var_req_builder.query(&[("Distance", &local_var_str.to_string())]);
7718    }
7719    if let Some(ref local_var_str) = in_postal_code {
7720        local_var_req_builder = local_var_req_builder.query(&[("InPostalCode", &local_var_str.to_string())]);
7721    }
7722    if let Some(ref local_var_str) = in_region {
7723        local_var_req_builder = local_var_req_builder.query(&[("InRegion", &local_var_str.to_string())]);
7724    }
7725    if let Some(ref local_var_str) = in_rate_center {
7726        local_var_req_builder = local_var_req_builder.query(&[("InRateCenter", &local_var_str.to_string())]);
7727    }
7728    if let Some(ref local_var_str) = in_lata {
7729        local_var_req_builder = local_var_req_builder.query(&[("InLata", &local_var_str.to_string())]);
7730    }
7731    if let Some(ref local_var_str) = in_locality {
7732        local_var_req_builder = local_var_req_builder.query(&[("InLocality", &local_var_str.to_string())]);
7733    }
7734    if let Some(ref local_var_str) = fax_enabled {
7735        local_var_req_builder = local_var_req_builder.query(&[("FaxEnabled", &local_var_str.to_string())]);
7736    }
7737    if let Some(ref local_var_str) = page_size {
7738        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7739    }
7740    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7741        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7742    }
7743    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7744        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7745    };
7746
7747    let local_var_req = local_var_req_builder.build()?;
7748    let local_var_resp = local_var_client.execute(local_var_req).await?;
7749
7750    let local_var_status = local_var_resp.status();
7751    let local_var_content = local_var_resp.text().await?;
7752
7753    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7754        serde_json::from_str(&local_var_content).map_err(Error::from)
7755    } else {
7756        let local_var_entity: Option<ListAvailablePhoneNumberVoipError> = serde_json::from_str(&local_var_content).ok();
7757        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7758        Err(Error::ResponseError(local_var_error))
7759    }
7760}
7761
7762/// Retrieves a collection of calls made to and from your account
7763pub async fn list_call(configuration: &configuration::Configuration, account_sid: &str, to: Option<&str>, from: Option<&str>, parent_call_sid: Option<&str>, status: Option<&str>, start_time: Option<String>, start_time_less_than: Option<String>, start_time_greater_than: Option<String>, end_time: Option<String>, end_time_less_than: Option<String>, end_time_greater_than: Option<String>, page_size: Option<i32>) -> Result<crate::models::ListCallResponse, Error<ListCallError>> {
7764    let local_var_configuration = configuration;
7765
7766    let local_var_client = &local_var_configuration.client;
7767
7768    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
7769    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7770
7771    if let Some(ref local_var_str) = to {
7772        local_var_req_builder = local_var_req_builder.query(&[("To", &local_var_str.to_string())]);
7773    }
7774    if let Some(ref local_var_str) = from {
7775        local_var_req_builder = local_var_req_builder.query(&[("From", &local_var_str.to_string())]);
7776    }
7777    if let Some(ref local_var_str) = parent_call_sid {
7778        local_var_req_builder = local_var_req_builder.query(&[("ParentCallSid", &local_var_str.to_string())]);
7779    }
7780    if let Some(ref local_var_str) = status {
7781        local_var_req_builder = local_var_req_builder.query(&[("Status", &local_var_str.to_string())]);
7782    }
7783    if let Some(ref local_var_str) = start_time {
7784        local_var_req_builder = local_var_req_builder.query(&[("StartTime", &local_var_str.to_string())]);
7785    }
7786    if let Some(ref local_var_str) = start_time_less_than {
7787        local_var_req_builder = local_var_req_builder.query(&[("StartTime<", &local_var_str.to_string())]);
7788    }
7789    if let Some(ref local_var_str) = start_time_greater_than {
7790        local_var_req_builder = local_var_req_builder.query(&[("StartTime>", &local_var_str.to_string())]);
7791    }
7792    if let Some(ref local_var_str) = end_time {
7793        local_var_req_builder = local_var_req_builder.query(&[("EndTime", &local_var_str.to_string())]);
7794    }
7795    if let Some(ref local_var_str) = end_time_less_than {
7796        local_var_req_builder = local_var_req_builder.query(&[("EndTime<", &local_var_str.to_string())]);
7797    }
7798    if let Some(ref local_var_str) = end_time_greater_than {
7799        local_var_req_builder = local_var_req_builder.query(&[("EndTime>", &local_var_str.to_string())]);
7800    }
7801    if let Some(ref local_var_str) = page_size {
7802        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7803    }
7804    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7805        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7806    }
7807    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7808        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7809    };
7810
7811    let local_var_req = local_var_req_builder.build()?;
7812    let local_var_resp = local_var_client.execute(local_var_req).await?;
7813
7814    let local_var_status = local_var_resp.status();
7815    let local_var_content = local_var_resp.text().await?;
7816
7817    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7818        serde_json::from_str(&local_var_content).map_err(Error::from)
7819    } else {
7820        let local_var_entity: Option<ListCallError> = serde_json::from_str(&local_var_content).ok();
7821        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7822        Err(Error::ResponseError(local_var_error))
7823    }
7824}
7825
7826/// Retrieve a list of all events for a call.
7827pub async fn list_call_event(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListCallEventResponse, Error<ListCallEventError>> {
7828    let local_var_configuration = configuration;
7829
7830    let local_var_client = &local_var_configuration.client;
7831
7832    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Events.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
7833    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7834
7835    if let Some(ref local_var_str) = page_size {
7836        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7837    }
7838    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7839        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7840    }
7841    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7842        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7843    };
7844
7845    let local_var_req = local_var_req_builder.build()?;
7846    let local_var_resp = local_var_client.execute(local_var_req).await?;
7847
7848    let local_var_status = local_var_resp.status();
7849    let local_var_content = local_var_resp.text().await?;
7850
7851    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7852        serde_json::from_str(&local_var_content).map_err(Error::from)
7853    } else {
7854        let local_var_entity: Option<ListCallEventError> = serde_json::from_str(&local_var_content).ok();
7855        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7856        Err(Error::ResponseError(local_var_error))
7857    }
7858}
7859
7860/// 
7861pub async fn list_call_notification(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, log: Option<i32>, message_date: Option<String>, message_date_less_than: Option<String>, message_date_greater_than: Option<String>, page_size: Option<i32>) -> Result<crate::models::ListCallNotificationResponse, Error<ListCallNotificationError>> {
7862    let local_var_configuration = configuration;
7863
7864    let local_var_client = &local_var_configuration.client;
7865
7866    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Notifications.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
7867    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7868
7869    if let Some(ref local_var_str) = log {
7870        local_var_req_builder = local_var_req_builder.query(&[("Log", &local_var_str.to_string())]);
7871    }
7872    if let Some(ref local_var_str) = message_date {
7873        local_var_req_builder = local_var_req_builder.query(&[("MessageDate", &local_var_str.to_string())]);
7874    }
7875    if let Some(ref local_var_str) = message_date_less_than {
7876        local_var_req_builder = local_var_req_builder.query(&[("MessageDate<", &local_var_str.to_string())]);
7877    }
7878    if let Some(ref local_var_str) = message_date_greater_than {
7879        local_var_req_builder = local_var_req_builder.query(&[("MessageDate>", &local_var_str.to_string())]);
7880    }
7881    if let Some(ref local_var_str) = page_size {
7882        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7883    }
7884    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7885        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7886    }
7887    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7888        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7889    };
7890
7891    let local_var_req = local_var_req_builder.build()?;
7892    let local_var_resp = local_var_client.execute(local_var_req).await?;
7893
7894    let local_var_status = local_var_resp.status();
7895    let local_var_content = local_var_resp.text().await?;
7896
7897    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7898        serde_json::from_str(&local_var_content).map_err(Error::from)
7899    } else {
7900        let local_var_entity: Option<ListCallNotificationError> = serde_json::from_str(&local_var_content).ok();
7901        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7902        Err(Error::ResponseError(local_var_error))
7903    }
7904}
7905
7906/// Retrieve a list of recordings belonging to the call used to make the request
7907pub async fn list_call_recording(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, date_created: Option<String>, date_created_less_than: Option<String>, date_created_greater_than: Option<String>, page_size: Option<i32>) -> Result<crate::models::ListCallRecordingResponse, Error<ListCallRecordingError>> {
7908    let local_var_configuration = configuration;
7909
7910    let local_var_client = &local_var_configuration.client;
7911
7912    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Recordings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
7913    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7914
7915    if let Some(ref local_var_str) = date_created {
7916        local_var_req_builder = local_var_req_builder.query(&[("DateCreated", &local_var_str.to_string())]);
7917    }
7918    if let Some(ref local_var_str) = date_created_less_than {
7919        local_var_req_builder = local_var_req_builder.query(&[("DateCreated<", &local_var_str.to_string())]);
7920    }
7921    if let Some(ref local_var_str) = date_created_greater_than {
7922        local_var_req_builder = local_var_req_builder.query(&[("DateCreated>", &local_var_str.to_string())]);
7923    }
7924    if let Some(ref local_var_str) = page_size {
7925        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7926    }
7927    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7928        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7929    }
7930    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7931        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7932    };
7933
7934    let local_var_req = local_var_req_builder.build()?;
7935    let local_var_resp = local_var_client.execute(local_var_req).await?;
7936
7937    let local_var_status = local_var_resp.status();
7938    let local_var_content = local_var_resp.text().await?;
7939
7940    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7941        serde_json::from_str(&local_var_content).map_err(Error::from)
7942    } else {
7943        let local_var_entity: Option<ListCallRecordingError> = serde_json::from_str(&local_var_content).ok();
7944        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
7945        Err(Error::ResponseError(local_var_error))
7946    }
7947}
7948
7949/// Retrieve a list of conferences belonging to the account used to make the request
7950pub async fn list_conference(configuration: &configuration::Configuration, account_sid: &str, date_created: Option<String>, date_created_less_than: Option<String>, date_created_greater_than: Option<String>, date_updated: Option<String>, date_updated_less_than: Option<String>, date_updated_greater_than: Option<String>, friendly_name: Option<&str>, status: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListConferenceResponse, Error<ListConferenceError>> {
7951    let local_var_configuration = configuration;
7952
7953    let local_var_client = &local_var_configuration.client;
7954
7955    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
7956    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
7957
7958    if let Some(ref local_var_str) = date_created {
7959        local_var_req_builder = local_var_req_builder.query(&[("DateCreated", &local_var_str.to_string())]);
7960    }
7961    if let Some(ref local_var_str) = date_created_less_than {
7962        local_var_req_builder = local_var_req_builder.query(&[("DateCreated<", &local_var_str.to_string())]);
7963    }
7964    if let Some(ref local_var_str) = date_created_greater_than {
7965        local_var_req_builder = local_var_req_builder.query(&[("DateCreated>", &local_var_str.to_string())]);
7966    }
7967    if let Some(ref local_var_str) = date_updated {
7968        local_var_req_builder = local_var_req_builder.query(&[("DateUpdated", &local_var_str.to_string())]);
7969    }
7970    if let Some(ref local_var_str) = date_updated_less_than {
7971        local_var_req_builder = local_var_req_builder.query(&[("DateUpdated<", &local_var_str.to_string())]);
7972    }
7973    if let Some(ref local_var_str) = date_updated_greater_than {
7974        local_var_req_builder = local_var_req_builder.query(&[("DateUpdated>", &local_var_str.to_string())]);
7975    }
7976    if let Some(ref local_var_str) = friendly_name {
7977        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
7978    }
7979    if let Some(ref local_var_str) = status {
7980        local_var_req_builder = local_var_req_builder.query(&[("Status", &local_var_str.to_string())]);
7981    }
7982    if let Some(ref local_var_str) = page_size {
7983        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
7984    }
7985    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
7986        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
7987    }
7988    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
7989        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
7990    };
7991
7992    let local_var_req = local_var_req_builder.build()?;
7993    let local_var_resp = local_var_client.execute(local_var_req).await?;
7994
7995    let local_var_status = local_var_resp.status();
7996    let local_var_content = local_var_resp.text().await?;
7997
7998    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
7999        serde_json::from_str(&local_var_content).map_err(Error::from)
8000    } else {
8001        let local_var_entity: Option<ListConferenceError> = serde_json::from_str(&local_var_content).ok();
8002        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8003        Err(Error::ResponseError(local_var_error))
8004    }
8005}
8006
8007/// Retrieve a list of recordings belonging to the call used to make the request
8008pub async fn list_conference_recording(configuration: &configuration::Configuration, account_sid: &str, conference_sid: &str, date_created: Option<String>, date_created_less_than: Option<String>, date_created_greater_than: Option<String>, page_size: Option<i32>) -> Result<crate::models::ListConferenceRecordingResponse, Error<ListConferenceRecordingError>> {
8009    let local_var_configuration = configuration;
8010
8011    let local_var_client = &local_var_configuration.client;
8012
8013    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{ConferenceSid}/Recordings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConferenceSid=crate::apis::urlencode(conference_sid));
8014    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8015
8016    if let Some(ref local_var_str) = date_created {
8017        local_var_req_builder = local_var_req_builder.query(&[("DateCreated", &local_var_str.to_string())]);
8018    }
8019    if let Some(ref local_var_str) = date_created_less_than {
8020        local_var_req_builder = local_var_req_builder.query(&[("DateCreated<", &local_var_str.to_string())]);
8021    }
8022    if let Some(ref local_var_str) = date_created_greater_than {
8023        local_var_req_builder = local_var_req_builder.query(&[("DateCreated>", &local_var_str.to_string())]);
8024    }
8025    if let Some(ref local_var_str) = page_size {
8026        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8027    }
8028    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8029        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8030    }
8031    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8032        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8033    };
8034
8035    let local_var_req = local_var_req_builder.build()?;
8036    let local_var_resp = local_var_client.execute(local_var_req).await?;
8037
8038    let local_var_status = local_var_resp.status();
8039    let local_var_content = local_var_resp.text().await?;
8040
8041    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8042        serde_json::from_str(&local_var_content).map_err(Error::from)
8043    } else {
8044        let local_var_entity: Option<ListConferenceRecordingError> = serde_json::from_str(&local_var_content).ok();
8045        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8046        Err(Error::ResponseError(local_var_error))
8047    }
8048}
8049
8050/// Retrieve a list of connect-apps belonging to the account used to make the request
8051pub async fn list_connect_app(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListConnectAppResponse, Error<ListConnectAppError>> {
8052    let local_var_configuration = configuration;
8053
8054    let local_var_client = &local_var_configuration.client;
8055
8056    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/ConnectApps.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8057    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8058
8059    if let Some(ref local_var_str) = page_size {
8060        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8061    }
8062    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8063        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8064    }
8065    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8066        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8067    };
8068
8069    let local_var_req = local_var_req_builder.build()?;
8070    let local_var_resp = local_var_client.execute(local_var_req).await?;
8071
8072    let local_var_status = local_var_resp.status();
8073    let local_var_content = local_var_resp.text().await?;
8074
8075    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8076        serde_json::from_str(&local_var_content).map_err(Error::from)
8077    } else {
8078        let local_var_entity: Option<ListConnectAppError> = serde_json::from_str(&local_var_content).ok();
8079        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8080        Err(Error::ResponseError(local_var_error))
8081    }
8082}
8083
8084/// 
8085pub async fn list_dependent_phone_number(configuration: &configuration::Configuration, account_sid: &str, address_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListDependentPhoneNumberResponse, Error<ListDependentPhoneNumberError>> {
8086    let local_var_configuration = configuration;
8087
8088    let local_var_client = &local_var_configuration.client;
8089
8090    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Addresses/{AddressSid}/DependentPhoneNumbers.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), AddressSid=crate::apis::urlencode(address_sid));
8091    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8092
8093    if let Some(ref local_var_str) = page_size {
8094        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8095    }
8096    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8097        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8098    }
8099    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8100        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8101    };
8102
8103    let local_var_req = local_var_req_builder.build()?;
8104    let local_var_resp = local_var_client.execute(local_var_req).await?;
8105
8106    let local_var_status = local_var_resp.status();
8107    let local_var_content = local_var_resp.text().await?;
8108
8109    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8110        serde_json::from_str(&local_var_content).map_err(Error::from)
8111    } else {
8112        let local_var_entity: Option<ListDependentPhoneNumberError> = serde_json::from_str(&local_var_content).ok();
8113        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8114        Err(Error::ResponseError(local_var_error))
8115    }
8116}
8117
8118/// Retrieve a list of incoming-phone-numbers belonging to the account used to make the request.
8119pub async fn list_incoming_phone_number(configuration: &configuration::Configuration, account_sid: &str, beta: Option<bool>, friendly_name: Option<&str>, phone_number: Option<&str>, origin: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListIncomingPhoneNumberResponse, Error<ListIncomingPhoneNumberError>> {
8120    let local_var_configuration = configuration;
8121
8122    let local_var_client = &local_var_configuration.client;
8123
8124    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8125    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8126
8127    if let Some(ref local_var_str) = beta {
8128        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
8129    }
8130    if let Some(ref local_var_str) = friendly_name {
8131        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
8132    }
8133    if let Some(ref local_var_str) = phone_number {
8134        local_var_req_builder = local_var_req_builder.query(&[("PhoneNumber", &local_var_str.to_string())]);
8135    }
8136    if let Some(ref local_var_str) = origin {
8137        local_var_req_builder = local_var_req_builder.query(&[("Origin", &local_var_str.to_string())]);
8138    }
8139    if let Some(ref local_var_str) = page_size {
8140        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8141    }
8142    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8143        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8144    }
8145    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8146        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8147    };
8148
8149    let local_var_req = local_var_req_builder.build()?;
8150    let local_var_resp = local_var_client.execute(local_var_req).await?;
8151
8152    let local_var_status = local_var_resp.status();
8153    let local_var_content = local_var_resp.text().await?;
8154
8155    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8156        serde_json::from_str(&local_var_content).map_err(Error::from)
8157    } else {
8158        let local_var_entity: Option<ListIncomingPhoneNumberError> = serde_json::from_str(&local_var_content).ok();
8159        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8160        Err(Error::ResponseError(local_var_error))
8161    }
8162}
8163
8164/// Retrieve a list of Add-on installations currently assigned to this Number.
8165pub async fn list_incoming_phone_number_assigned_add_on(configuration: &configuration::Configuration, account_sid: &str, resource_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListIncomingPhoneNumberAssignedAddOnResponse, Error<ListIncomingPhoneNumberAssignedAddOnError>> {
8166    let local_var_configuration = configuration;
8167
8168    let local_var_client = &local_var_configuration.client;
8169
8170    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/{ResourceSid}/AssignedAddOns.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ResourceSid=crate::apis::urlencode(resource_sid));
8171    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8172
8173    if let Some(ref local_var_str) = page_size {
8174        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8175    }
8176    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8177        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8178    }
8179    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8180        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8181    };
8182
8183    let local_var_req = local_var_req_builder.build()?;
8184    let local_var_resp = local_var_client.execute(local_var_req).await?;
8185
8186    let local_var_status = local_var_resp.status();
8187    let local_var_content = local_var_resp.text().await?;
8188
8189    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8190        serde_json::from_str(&local_var_content).map_err(Error::from)
8191    } else {
8192        let local_var_entity: Option<ListIncomingPhoneNumberAssignedAddOnError> = serde_json::from_str(&local_var_content).ok();
8193        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8194        Err(Error::ResponseError(local_var_error))
8195    }
8196}
8197
8198/// Retrieve a list of Extensions for the Assigned Add-on.
8199pub async fn list_incoming_phone_number_assigned_add_on_extension(configuration: &configuration::Configuration, account_sid: &str, resource_sid: &str, assigned_add_on_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListIncomingPhoneNumberAssignedAddOnExtensionResponse, Error<ListIncomingPhoneNumberAssignedAddOnExtensionError>> {
8200    let local_var_configuration = configuration;
8201
8202    let local_var_client = &local_var_configuration.client;
8203
8204    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/{ResourceSid}/AssignedAddOns/{AssignedAddOnSid}/Extensions.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ResourceSid=crate::apis::urlencode(resource_sid), AssignedAddOnSid=crate::apis::urlencode(assigned_add_on_sid));
8205    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8206
8207    if let Some(ref local_var_str) = page_size {
8208        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8209    }
8210    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8211        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8212    }
8213    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8214        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8215    };
8216
8217    let local_var_req = local_var_req_builder.build()?;
8218    let local_var_resp = local_var_client.execute(local_var_req).await?;
8219
8220    let local_var_status = local_var_resp.status();
8221    let local_var_content = local_var_resp.text().await?;
8222
8223    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8224        serde_json::from_str(&local_var_content).map_err(Error::from)
8225    } else {
8226        let local_var_entity: Option<ListIncomingPhoneNumberAssignedAddOnExtensionError> = serde_json::from_str(&local_var_content).ok();
8227        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8228        Err(Error::ResponseError(local_var_error))
8229    }
8230}
8231
8232/// 
8233pub async fn list_incoming_phone_number_local(configuration: &configuration::Configuration, account_sid: &str, beta: Option<bool>, friendly_name: Option<&str>, phone_number: Option<&str>, origin: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListIncomingPhoneNumberLocalResponse, Error<ListIncomingPhoneNumberLocalError>> {
8234    let local_var_configuration = configuration;
8235
8236    let local_var_client = &local_var_configuration.client;
8237
8238    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/Local.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8239    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8240
8241    if let Some(ref local_var_str) = beta {
8242        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
8243    }
8244    if let Some(ref local_var_str) = friendly_name {
8245        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
8246    }
8247    if let Some(ref local_var_str) = phone_number {
8248        local_var_req_builder = local_var_req_builder.query(&[("PhoneNumber", &local_var_str.to_string())]);
8249    }
8250    if let Some(ref local_var_str) = origin {
8251        local_var_req_builder = local_var_req_builder.query(&[("Origin", &local_var_str.to_string())]);
8252    }
8253    if let Some(ref local_var_str) = page_size {
8254        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8255    }
8256    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8257        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8258    }
8259    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8260        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8261    };
8262
8263    let local_var_req = local_var_req_builder.build()?;
8264    let local_var_resp = local_var_client.execute(local_var_req).await?;
8265
8266    let local_var_status = local_var_resp.status();
8267    let local_var_content = local_var_resp.text().await?;
8268
8269    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8270        serde_json::from_str(&local_var_content).map_err(Error::from)
8271    } else {
8272        let local_var_entity: Option<ListIncomingPhoneNumberLocalError> = serde_json::from_str(&local_var_content).ok();
8273        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8274        Err(Error::ResponseError(local_var_error))
8275    }
8276}
8277
8278/// 
8279pub async fn list_incoming_phone_number_mobile(configuration: &configuration::Configuration, account_sid: &str, beta: Option<bool>, friendly_name: Option<&str>, phone_number: Option<&str>, origin: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListIncomingPhoneNumberMobileResponse, Error<ListIncomingPhoneNumberMobileError>> {
8280    let local_var_configuration = configuration;
8281
8282    let local_var_client = &local_var_configuration.client;
8283
8284    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/Mobile.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8285    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8286
8287    if let Some(ref local_var_str) = beta {
8288        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
8289    }
8290    if let Some(ref local_var_str) = friendly_name {
8291        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
8292    }
8293    if let Some(ref local_var_str) = phone_number {
8294        local_var_req_builder = local_var_req_builder.query(&[("PhoneNumber", &local_var_str.to_string())]);
8295    }
8296    if let Some(ref local_var_str) = origin {
8297        local_var_req_builder = local_var_req_builder.query(&[("Origin", &local_var_str.to_string())]);
8298    }
8299    if let Some(ref local_var_str) = page_size {
8300        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8301    }
8302    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8303        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8304    }
8305    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8306        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8307    };
8308
8309    let local_var_req = local_var_req_builder.build()?;
8310    let local_var_resp = local_var_client.execute(local_var_req).await?;
8311
8312    let local_var_status = local_var_resp.status();
8313    let local_var_content = local_var_resp.text().await?;
8314
8315    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8316        serde_json::from_str(&local_var_content).map_err(Error::from)
8317    } else {
8318        let local_var_entity: Option<ListIncomingPhoneNumberMobileError> = serde_json::from_str(&local_var_content).ok();
8319        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8320        Err(Error::ResponseError(local_var_error))
8321    }
8322}
8323
8324/// 
8325pub async fn list_incoming_phone_number_toll_free(configuration: &configuration::Configuration, account_sid: &str, beta: Option<bool>, friendly_name: Option<&str>, phone_number: Option<&str>, origin: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListIncomingPhoneNumberTollFreeResponse, Error<ListIncomingPhoneNumberTollFreeError>> {
8326    let local_var_configuration = configuration;
8327
8328    let local_var_client = &local_var_configuration.client;
8329
8330    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/TollFree.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8331    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8332
8333    if let Some(ref local_var_str) = beta {
8334        local_var_req_builder = local_var_req_builder.query(&[("Beta", &local_var_str.to_string())]);
8335    }
8336    if let Some(ref local_var_str) = friendly_name {
8337        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
8338    }
8339    if let Some(ref local_var_str) = phone_number {
8340        local_var_req_builder = local_var_req_builder.query(&[("PhoneNumber", &local_var_str.to_string())]);
8341    }
8342    if let Some(ref local_var_str) = origin {
8343        local_var_req_builder = local_var_req_builder.query(&[("Origin", &local_var_str.to_string())]);
8344    }
8345    if let Some(ref local_var_str) = page_size {
8346        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8347    }
8348    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8349        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8350    }
8351    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8352        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8353    };
8354
8355    let local_var_req = local_var_req_builder.build()?;
8356    let local_var_resp = local_var_client.execute(local_var_req).await?;
8357
8358    let local_var_status = local_var_resp.status();
8359    let local_var_content = local_var_resp.text().await?;
8360
8361    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8362        serde_json::from_str(&local_var_content).map_err(Error::from)
8363    } else {
8364        let local_var_entity: Option<ListIncomingPhoneNumberTollFreeError> = serde_json::from_str(&local_var_content).ok();
8365        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8366        Err(Error::ResponseError(local_var_error))
8367    }
8368}
8369
8370/// 
8371pub async fn list_key(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListKeyResponse, Error<ListKeyError>> {
8372    let local_var_configuration = configuration;
8373
8374    let local_var_client = &local_var_configuration.client;
8375
8376    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Keys.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8377    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8378
8379    if let Some(ref local_var_str) = page_size {
8380        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8381    }
8382    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8383        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8384    }
8385    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8386        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8387    };
8388
8389    let local_var_req = local_var_req_builder.build()?;
8390    let local_var_resp = local_var_client.execute(local_var_req).await?;
8391
8392    let local_var_status = local_var_resp.status();
8393    let local_var_content = local_var_resp.text().await?;
8394
8395    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8396        serde_json::from_str(&local_var_content).map_err(Error::from)
8397    } else {
8398        let local_var_entity: Option<ListKeyError> = serde_json::from_str(&local_var_content).ok();
8399        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8400        Err(Error::ResponseError(local_var_error))
8401    }
8402}
8403
8404/// Retrieve a list of Media resources belonging to the account used to make the request
8405pub async fn list_media(configuration: &configuration::Configuration, account_sid: &str, message_sid: &str, date_created: Option<String>, date_created_less_than: Option<String>, date_created_greater_than: Option<String>, page_size: Option<i32>) -> Result<crate::models::ListMediaResponse, Error<ListMediaError>> {
8406    let local_var_configuration = configuration;
8407
8408    let local_var_client = &local_var_configuration.client;
8409
8410    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{MessageSid}/Media.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), MessageSid=crate::apis::urlencode(message_sid));
8411    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8412
8413    if let Some(ref local_var_str) = date_created {
8414        local_var_req_builder = local_var_req_builder.query(&[("DateCreated", &local_var_str.to_string())]);
8415    }
8416    if let Some(ref local_var_str) = date_created_less_than {
8417        local_var_req_builder = local_var_req_builder.query(&[("DateCreated<", &local_var_str.to_string())]);
8418    }
8419    if let Some(ref local_var_str) = date_created_greater_than {
8420        local_var_req_builder = local_var_req_builder.query(&[("DateCreated>", &local_var_str.to_string())]);
8421    }
8422    if let Some(ref local_var_str) = page_size {
8423        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8424    }
8425    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8426        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8427    }
8428    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8429        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8430    };
8431
8432    let local_var_req = local_var_req_builder.build()?;
8433    let local_var_resp = local_var_client.execute(local_var_req).await?;
8434
8435    let local_var_status = local_var_resp.status();
8436    let local_var_content = local_var_resp.text().await?;
8437
8438    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8439        serde_json::from_str(&local_var_content).map_err(Error::from)
8440    } else {
8441        let local_var_entity: Option<ListMediaError> = serde_json::from_str(&local_var_content).ok();
8442        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8443        Err(Error::ResponseError(local_var_error))
8444    }
8445}
8446
8447/// Retrieve the members of the queue
8448pub async fn list_member(configuration: &configuration::Configuration, account_sid: &str, queue_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListMemberResponse, Error<ListMemberError>> {
8449    let local_var_configuration = configuration;
8450
8451    let local_var_client = &local_var_configuration.client;
8452
8453    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Queues/{QueueSid}/Members.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), QueueSid=crate::apis::urlencode(queue_sid));
8454    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8455
8456    if let Some(ref local_var_str) = page_size {
8457        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8458    }
8459    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8460        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8461    }
8462    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8463        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8464    };
8465
8466    let local_var_req = local_var_req_builder.build()?;
8467    let local_var_resp = local_var_client.execute(local_var_req).await?;
8468
8469    let local_var_status = local_var_resp.status();
8470    let local_var_content = local_var_resp.text().await?;
8471
8472    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8473        serde_json::from_str(&local_var_content).map_err(Error::from)
8474    } else {
8475        let local_var_entity: Option<ListMemberError> = serde_json::from_str(&local_var_content).ok();
8476        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8477        Err(Error::ResponseError(local_var_error))
8478    }
8479}
8480
8481/// Retrieve a list of messages belonging to the account used to make the request
8482pub async fn list_message(configuration: &configuration::Configuration, account_sid: &str, to: Option<&str>, from: Option<&str>, date_sent: Option<String>, date_sent_less_than: Option<String>, date_sent_greater_than: Option<String>, page_size: Option<i32>) -> Result<crate::models::ListMessageResponse, Error<ListMessageError>> {
8483    let local_var_configuration = configuration;
8484
8485    let local_var_client = &local_var_configuration.client;
8486
8487    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8488    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8489
8490    if let Some(ref local_var_str) = to {
8491        local_var_req_builder = local_var_req_builder.query(&[("To", &local_var_str.to_string())]);
8492    }
8493    if let Some(ref local_var_str) = from {
8494        local_var_req_builder = local_var_req_builder.query(&[("From", &local_var_str.to_string())]);
8495    }
8496    if let Some(ref local_var_str) = date_sent {
8497        local_var_req_builder = local_var_req_builder.query(&[("DateSent", &local_var_str.to_string())]);
8498    }
8499    if let Some(ref local_var_str) = date_sent_less_than {
8500        local_var_req_builder = local_var_req_builder.query(&[("DateSent<", &local_var_str.to_string())]);
8501    }
8502    if let Some(ref local_var_str) = date_sent_greater_than {
8503        local_var_req_builder = local_var_req_builder.query(&[("DateSent>", &local_var_str.to_string())]);
8504    }
8505    if let Some(ref local_var_str) = page_size {
8506        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8507    }
8508    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8509        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8510    }
8511    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8512        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8513    };
8514
8515    let local_var_req = local_var_req_builder.build()?;
8516    let local_var_resp = local_var_client.execute(local_var_req).await?;
8517
8518    let local_var_status = local_var_resp.status();
8519    let local_var_content = local_var_resp.text().await?;
8520
8521    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8522        serde_json::from_str(&local_var_content).map_err(Error::from)
8523    } else {
8524        let local_var_entity: Option<ListMessageError> = serde_json::from_str(&local_var_content).ok();
8525        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8526        Err(Error::ResponseError(local_var_error))
8527    }
8528}
8529
8530/// Retrieve a list of notifications belonging to the account used to make the request
8531pub async fn list_notification(configuration: &configuration::Configuration, account_sid: &str, log: Option<i32>, message_date: Option<String>, message_date_less_than: Option<String>, message_date_greater_than: Option<String>, page_size: Option<i32>) -> Result<crate::models::ListNotificationResponse, Error<ListNotificationError>> {
8532    let local_var_configuration = configuration;
8533
8534    let local_var_client = &local_var_configuration.client;
8535
8536    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Notifications.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8537    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8538
8539    if let Some(ref local_var_str) = log {
8540        local_var_req_builder = local_var_req_builder.query(&[("Log", &local_var_str.to_string())]);
8541    }
8542    if let Some(ref local_var_str) = message_date {
8543        local_var_req_builder = local_var_req_builder.query(&[("MessageDate", &local_var_str.to_string())]);
8544    }
8545    if let Some(ref local_var_str) = message_date_less_than {
8546        local_var_req_builder = local_var_req_builder.query(&[("MessageDate<", &local_var_str.to_string())]);
8547    }
8548    if let Some(ref local_var_str) = message_date_greater_than {
8549        local_var_req_builder = local_var_req_builder.query(&[("MessageDate>", &local_var_str.to_string())]);
8550    }
8551    if let Some(ref local_var_str) = page_size {
8552        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8553    }
8554    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8555        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8556    }
8557    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8558        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8559    };
8560
8561    let local_var_req = local_var_req_builder.build()?;
8562    let local_var_resp = local_var_client.execute(local_var_req).await?;
8563
8564    let local_var_status = local_var_resp.status();
8565    let local_var_content = local_var_resp.text().await?;
8566
8567    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8568        serde_json::from_str(&local_var_content).map_err(Error::from)
8569    } else {
8570        let local_var_entity: Option<ListNotificationError> = serde_json::from_str(&local_var_content).ok();
8571        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8572        Err(Error::ResponseError(local_var_error))
8573    }
8574}
8575
8576/// Retrieve a list of outgoing-caller-ids belonging to the account used to make the request
8577pub async fn list_outgoing_caller_id(configuration: &configuration::Configuration, account_sid: &str, phone_number: Option<&str>, friendly_name: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListOutgoingCallerIdResponse, Error<ListOutgoingCallerIdError>> {
8578    let local_var_configuration = configuration;
8579
8580    let local_var_client = &local_var_configuration.client;
8581
8582    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/OutgoingCallerIds.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8583    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8584
8585    if let Some(ref local_var_str) = phone_number {
8586        local_var_req_builder = local_var_req_builder.query(&[("PhoneNumber", &local_var_str.to_string())]);
8587    }
8588    if let Some(ref local_var_str) = friendly_name {
8589        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
8590    }
8591    if let Some(ref local_var_str) = page_size {
8592        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8593    }
8594    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8595        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8596    }
8597    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8598        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8599    };
8600
8601    let local_var_req = local_var_req_builder.build()?;
8602    let local_var_resp = local_var_client.execute(local_var_req).await?;
8603
8604    let local_var_status = local_var_resp.status();
8605    let local_var_content = local_var_resp.text().await?;
8606
8607    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8608        serde_json::from_str(&local_var_content).map_err(Error::from)
8609    } else {
8610        let local_var_entity: Option<ListOutgoingCallerIdError> = serde_json::from_str(&local_var_content).ok();
8611        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8612        Err(Error::ResponseError(local_var_error))
8613    }
8614}
8615
8616/// Retrieve a list of participants belonging to the account used to make the request
8617pub async fn list_participant(configuration: &configuration::Configuration, account_sid: &str, conference_sid: &str, muted: Option<bool>, hold: Option<bool>, coaching: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListParticipantResponse, Error<ListParticipantError>> {
8618    let local_var_configuration = configuration;
8619
8620    let local_var_client = &local_var_configuration.client;
8621
8622    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{ConferenceSid}/Participants.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConferenceSid=crate::apis::urlencode(conference_sid));
8623    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8624
8625    if let Some(ref local_var_str) = muted {
8626        local_var_req_builder = local_var_req_builder.query(&[("Muted", &local_var_str.to_string())]);
8627    }
8628    if let Some(ref local_var_str) = hold {
8629        local_var_req_builder = local_var_req_builder.query(&[("Hold", &local_var_str.to_string())]);
8630    }
8631    if let Some(ref local_var_str) = coaching {
8632        local_var_req_builder = local_var_req_builder.query(&[("Coaching", &local_var_str.to_string())]);
8633    }
8634    if let Some(ref local_var_str) = page_size {
8635        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8636    }
8637    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8638        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8639    }
8640    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8641        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8642    };
8643
8644    let local_var_req = local_var_req_builder.build()?;
8645    let local_var_resp = local_var_client.execute(local_var_req).await?;
8646
8647    let local_var_status = local_var_resp.status();
8648    let local_var_content = local_var_resp.text().await?;
8649
8650    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8651        serde_json::from_str(&local_var_content).map_err(Error::from)
8652    } else {
8653        let local_var_entity: Option<ListParticipantError> = serde_json::from_str(&local_var_content).ok();
8654        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8655        Err(Error::ResponseError(local_var_error))
8656    }
8657}
8658
8659/// Retrieve a list of queues belonging to the account used to make the request
8660pub async fn list_queue(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListQueueResponse, Error<ListQueueError>> {
8661    let local_var_configuration = configuration;
8662
8663    let local_var_client = &local_var_configuration.client;
8664
8665    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Queues.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8666    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8667
8668    if let Some(ref local_var_str) = page_size {
8669        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8670    }
8671    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8672        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8673    }
8674    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8675        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8676    };
8677
8678    let local_var_req = local_var_req_builder.build()?;
8679    let local_var_resp = local_var_client.execute(local_var_req).await?;
8680
8681    let local_var_status = local_var_resp.status();
8682    let local_var_content = local_var_resp.text().await?;
8683
8684    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8685        serde_json::from_str(&local_var_content).map_err(Error::from)
8686    } else {
8687        let local_var_entity: Option<ListQueueError> = serde_json::from_str(&local_var_content).ok();
8688        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8689        Err(Error::ResponseError(local_var_error))
8690    }
8691}
8692
8693/// Retrieve a list of recordings belonging to the account used to make the request
8694pub async fn list_recording(configuration: &configuration::Configuration, account_sid: &str, date_created: Option<String>, date_created_less_than: Option<String>, date_created_greater_than: Option<String>, call_sid: Option<&str>, conference_sid: Option<&str>, include_soft_deleted: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListRecordingResponse, Error<ListRecordingError>> {
8695    let local_var_configuration = configuration;
8696
8697    let local_var_client = &local_var_configuration.client;
8698
8699    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8700    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8701
8702    if let Some(ref local_var_str) = date_created {
8703        local_var_req_builder = local_var_req_builder.query(&[("DateCreated", &local_var_str.to_string())]);
8704    }
8705    if let Some(ref local_var_str) = date_created_less_than {
8706        local_var_req_builder = local_var_req_builder.query(&[("DateCreated<", &local_var_str.to_string())]);
8707    }
8708    if let Some(ref local_var_str) = date_created_greater_than {
8709        local_var_req_builder = local_var_req_builder.query(&[("DateCreated>", &local_var_str.to_string())]);
8710    }
8711    if let Some(ref local_var_str) = call_sid {
8712        local_var_req_builder = local_var_req_builder.query(&[("CallSid", &local_var_str.to_string())]);
8713    }
8714    if let Some(ref local_var_str) = conference_sid {
8715        local_var_req_builder = local_var_req_builder.query(&[("ConferenceSid", &local_var_str.to_string())]);
8716    }
8717    if let Some(ref local_var_str) = include_soft_deleted {
8718        local_var_req_builder = local_var_req_builder.query(&[("IncludeSoftDeleted", &local_var_str.to_string())]);
8719    }
8720    if let Some(ref local_var_str) = page_size {
8721        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8722    }
8723    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8724        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8725    }
8726    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8727        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8728    };
8729
8730    let local_var_req = local_var_req_builder.build()?;
8731    let local_var_resp = local_var_client.execute(local_var_req).await?;
8732
8733    let local_var_status = local_var_resp.status();
8734    let local_var_content = local_var_resp.text().await?;
8735
8736    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8737        serde_json::from_str(&local_var_content).map_err(Error::from)
8738    } else {
8739        let local_var_entity: Option<ListRecordingError> = serde_json::from_str(&local_var_content).ok();
8740        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8741        Err(Error::ResponseError(local_var_error))
8742    }
8743}
8744
8745/// Retrieve a list of results belonging to the recording
8746pub async fn list_recording_add_on_result(configuration: &configuration::Configuration, account_sid: &str, reference_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListRecordingAddOnResultResponse, Error<ListRecordingAddOnResultError>> {
8747    let local_var_configuration = configuration;
8748
8749    let local_var_client = &local_var_configuration.client;
8750
8751    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{ReferenceSid}/AddOnResults.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ReferenceSid=crate::apis::urlencode(reference_sid));
8752    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8753
8754    if let Some(ref local_var_str) = page_size {
8755        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8756    }
8757    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8758        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8759    }
8760    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8761        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8762    };
8763
8764    let local_var_req = local_var_req_builder.build()?;
8765    let local_var_resp = local_var_client.execute(local_var_req).await?;
8766
8767    let local_var_status = local_var_resp.status();
8768    let local_var_content = local_var_resp.text().await?;
8769
8770    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8771        serde_json::from_str(&local_var_content).map_err(Error::from)
8772    } else {
8773        let local_var_entity: Option<ListRecordingAddOnResultError> = serde_json::from_str(&local_var_content).ok();
8774        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8775        Err(Error::ResponseError(local_var_error))
8776    }
8777}
8778
8779/// Retrieve a list of payloads belonging to the AddOnResult
8780pub async fn list_recording_add_on_result_payload(configuration: &configuration::Configuration, account_sid: &str, reference_sid: &str, add_on_result_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListRecordingAddOnResultPayloadResponse, Error<ListRecordingAddOnResultPayloadError>> {
8781    let local_var_configuration = configuration;
8782
8783    let local_var_client = &local_var_configuration.client;
8784
8785    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{ReferenceSid}/AddOnResults/{AddOnResultSid}/Payloads.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ReferenceSid=crate::apis::urlencode(reference_sid), AddOnResultSid=crate::apis::urlencode(add_on_result_sid));
8786    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8787
8788    if let Some(ref local_var_str) = page_size {
8789        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8790    }
8791    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8792        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8793    }
8794    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8795        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8796    };
8797
8798    let local_var_req = local_var_req_builder.build()?;
8799    let local_var_resp = local_var_client.execute(local_var_req).await?;
8800
8801    let local_var_status = local_var_resp.status();
8802    let local_var_content = local_var_resp.text().await?;
8803
8804    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8805        serde_json::from_str(&local_var_content).map_err(Error::from)
8806    } else {
8807        let local_var_entity: Option<ListRecordingAddOnResultPayloadError> = serde_json::from_str(&local_var_content).ok();
8808        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8809        Err(Error::ResponseError(local_var_error))
8810    }
8811}
8812
8813/// 
8814pub async fn list_recording_transcription(configuration: &configuration::Configuration, account_sid: &str, recording_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListRecordingTranscriptionResponse, Error<ListRecordingTranscriptionError>> {
8815    let local_var_configuration = configuration;
8816
8817    let local_var_client = &local_var_configuration.client;
8818
8819    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Recordings/{RecordingSid}/Transcriptions.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), RecordingSid=crate::apis::urlencode(recording_sid));
8820    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8821
8822    if let Some(ref local_var_str) = page_size {
8823        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8824    }
8825    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8826        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8827    }
8828    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8829        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8830    };
8831
8832    let local_var_req = local_var_req_builder.build()?;
8833    let local_var_resp = local_var_client.execute(local_var_req).await?;
8834
8835    let local_var_status = local_var_resp.status();
8836    let local_var_content = local_var_resp.text().await?;
8837
8838    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8839        serde_json::from_str(&local_var_content).map_err(Error::from)
8840    } else {
8841        let local_var_entity: Option<ListRecordingTranscriptionError> = serde_json::from_str(&local_var_content).ok();
8842        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8843        Err(Error::ResponseError(local_var_error))
8844    }
8845}
8846
8847/// Retrieve a list of short-codes belonging to the account used to make the request
8848pub async fn list_short_code(configuration: &configuration::Configuration, account_sid: &str, friendly_name: Option<&str>, short_code: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListShortCodeResponse, Error<ListShortCodeError>> {
8849    let local_var_configuration = configuration;
8850
8851    let local_var_client = &local_var_configuration.client;
8852
8853    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SMS/ShortCodes.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8854    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8855
8856    if let Some(ref local_var_str) = friendly_name {
8857        local_var_req_builder = local_var_req_builder.query(&[("FriendlyName", &local_var_str.to_string())]);
8858    }
8859    if let Some(ref local_var_str) = short_code {
8860        local_var_req_builder = local_var_req_builder.query(&[("ShortCode", &local_var_str.to_string())]);
8861    }
8862    if let Some(ref local_var_str) = page_size {
8863        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8864    }
8865    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8866        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8867    }
8868    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8869        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8870    };
8871
8872    let local_var_req = local_var_req_builder.build()?;
8873    let local_var_resp = local_var_client.execute(local_var_req).await?;
8874
8875    let local_var_status = local_var_resp.status();
8876    let local_var_content = local_var_resp.text().await?;
8877
8878    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8879        serde_json::from_str(&local_var_content).map_err(Error::from)
8880    } else {
8881        let local_var_entity: Option<ListShortCodeError> = serde_json::from_str(&local_var_content).ok();
8882        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8883        Err(Error::ResponseError(local_var_error))
8884    }
8885}
8886
8887/// 
8888pub async fn list_signing_key(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSigningKeyResponse, Error<ListSigningKeyError>> {
8889    let local_var_configuration = configuration;
8890
8891    let local_var_client = &local_var_configuration.client;
8892
8893    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SigningKeys.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
8894    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8895
8896    if let Some(ref local_var_str) = page_size {
8897        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8898    }
8899    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8900        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8901    }
8902    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8903        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8904    };
8905
8906    let local_var_req = local_var_req_builder.build()?;
8907    let local_var_resp = local_var_client.execute(local_var_req).await?;
8908
8909    let local_var_status = local_var_resp.status();
8910    let local_var_content = local_var_resp.text().await?;
8911
8912    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8913        serde_json::from_str(&local_var_content).map_err(Error::from)
8914    } else {
8915        let local_var_entity: Option<ListSigningKeyError> = serde_json::from_str(&local_var_content).ok();
8916        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8917        Err(Error::ResponseError(local_var_error))
8918    }
8919}
8920
8921/// Retrieve a list of credential list mappings belonging to the domain used in the request
8922pub async fn list_sip_auth_calls_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipAuthCallsCredentialListMappingResponse, Error<ListSipAuthCallsCredentialListMappingError>> {
8923    let local_var_configuration = configuration;
8924
8925    let local_var_client = &local_var_configuration.client;
8926
8927    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/CredentialListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
8928    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8929
8930    if let Some(ref local_var_str) = page_size {
8931        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8932    }
8933    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8934        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8935    }
8936    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8937        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8938    };
8939
8940    let local_var_req = local_var_req_builder.build()?;
8941    let local_var_resp = local_var_client.execute(local_var_req).await?;
8942
8943    let local_var_status = local_var_resp.status();
8944    let local_var_content = local_var_resp.text().await?;
8945
8946    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8947        serde_json::from_str(&local_var_content).map_err(Error::from)
8948    } else {
8949        let local_var_entity: Option<ListSipAuthCallsCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
8950        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8951        Err(Error::ResponseError(local_var_error))
8952    }
8953}
8954
8955/// Retrieve a list of IP Access Control List mappings belonging to the domain used in the request
8956pub async fn list_sip_auth_calls_ip_access_control_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipAuthCallsIpAccessControlListMappingResponse, Error<ListSipAuthCallsIpAccessControlListMappingError>> {
8957    let local_var_configuration = configuration;
8958
8959    let local_var_client = &local_var_configuration.client;
8960
8961    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Calls/IpAccessControlListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
8962    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8963
8964    if let Some(ref local_var_str) = page_size {
8965        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
8966    }
8967    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
8968        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
8969    }
8970    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
8971        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
8972    };
8973
8974    let local_var_req = local_var_req_builder.build()?;
8975    let local_var_resp = local_var_client.execute(local_var_req).await?;
8976
8977    let local_var_status = local_var_resp.status();
8978    let local_var_content = local_var_resp.text().await?;
8979
8980    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
8981        serde_json::from_str(&local_var_content).map_err(Error::from)
8982    } else {
8983        let local_var_entity: Option<ListSipAuthCallsIpAccessControlListMappingError> = serde_json::from_str(&local_var_content).ok();
8984        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
8985        Err(Error::ResponseError(local_var_error))
8986    }
8987}
8988
8989/// Retrieve a list of credential list mappings belonging to the domain used in the request
8990pub async fn list_sip_auth_registrations_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipAuthRegistrationsCredentialListMappingResponse, Error<ListSipAuthRegistrationsCredentialListMappingError>> {
8991    let local_var_configuration = configuration;
8992
8993    let local_var_client = &local_var_configuration.client;
8994
8995    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/Auth/Registrations/CredentialListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
8996    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
8997
8998    if let Some(ref local_var_str) = page_size {
8999        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9000    }
9001    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9002        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9003    }
9004    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9005        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9006    };
9007
9008    let local_var_req = local_var_req_builder.build()?;
9009    let local_var_resp = local_var_client.execute(local_var_req).await?;
9010
9011    let local_var_status = local_var_resp.status();
9012    let local_var_content = local_var_resp.text().await?;
9013
9014    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9015        serde_json::from_str(&local_var_content).map_err(Error::from)
9016    } else {
9017        let local_var_entity: Option<ListSipAuthRegistrationsCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
9018        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9019        Err(Error::ResponseError(local_var_error))
9020    }
9021}
9022
9023/// Retrieve a list of credentials.
9024pub async fn list_sip_credential(configuration: &configuration::Configuration, account_sid: &str, credential_list_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipCredentialResponse, Error<ListSipCredentialError>> {
9025    let local_var_configuration = configuration;
9026
9027    let local_var_client = &local_var_configuration.client;
9028
9029    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists/{CredentialListSid}/Credentials.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CredentialListSid=crate::apis::urlencode(credential_list_sid));
9030    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9031
9032    if let Some(ref local_var_str) = page_size {
9033        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9034    }
9035    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9036        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9037    }
9038    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9039        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9040    };
9041
9042    let local_var_req = local_var_req_builder.build()?;
9043    let local_var_resp = local_var_client.execute(local_var_req).await?;
9044
9045    let local_var_status = local_var_resp.status();
9046    let local_var_content = local_var_resp.text().await?;
9047
9048    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9049        serde_json::from_str(&local_var_content).map_err(Error::from)
9050    } else {
9051        let local_var_entity: Option<ListSipCredentialError> = serde_json::from_str(&local_var_content).ok();
9052        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9053        Err(Error::ResponseError(local_var_error))
9054    }
9055}
9056
9057/// Get All Credential Lists
9058pub async fn list_sip_credential_list(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipCredentialListResponse, Error<ListSipCredentialListError>> {
9059    let local_var_configuration = configuration;
9060
9061    let local_var_client = &local_var_configuration.client;
9062
9063    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9064    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9065
9066    if let Some(ref local_var_str) = page_size {
9067        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9068    }
9069    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9070        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9071    }
9072    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9073        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9074    };
9075
9076    let local_var_req = local_var_req_builder.build()?;
9077    let local_var_resp = local_var_client.execute(local_var_req).await?;
9078
9079    let local_var_status = local_var_resp.status();
9080    let local_var_content = local_var_resp.text().await?;
9081
9082    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9083        serde_json::from_str(&local_var_content).map_err(Error::from)
9084    } else {
9085        let local_var_entity: Option<ListSipCredentialListError> = serde_json::from_str(&local_var_content).ok();
9086        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9087        Err(Error::ResponseError(local_var_error))
9088    }
9089}
9090
9091/// Read multiple CredentialListMapping resources from an account.
9092pub async fn list_sip_credential_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipCredentialListMappingResponse, Error<ListSipCredentialListMappingError>> {
9093    let local_var_configuration = configuration;
9094
9095    let local_var_client = &local_var_configuration.client;
9096
9097    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/CredentialListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
9098    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9099
9100    if let Some(ref local_var_str) = page_size {
9101        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9102    }
9103    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9104        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9105    }
9106    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9107        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9108    };
9109
9110    let local_var_req = local_var_req_builder.build()?;
9111    let local_var_resp = local_var_client.execute(local_var_req).await?;
9112
9113    let local_var_status = local_var_resp.status();
9114    let local_var_content = local_var_resp.text().await?;
9115
9116    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9117        serde_json::from_str(&local_var_content).map_err(Error::from)
9118    } else {
9119        let local_var_entity: Option<ListSipCredentialListMappingError> = serde_json::from_str(&local_var_content).ok();
9120        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9121        Err(Error::ResponseError(local_var_error))
9122    }
9123}
9124
9125/// Retrieve a list of domains belonging to the account used to make the request
9126pub async fn list_sip_domain(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipDomainResponse, Error<ListSipDomainError>> {
9127    let local_var_configuration = configuration;
9128
9129    let local_var_client = &local_var_configuration.client;
9130
9131    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9132    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9133
9134    if let Some(ref local_var_str) = page_size {
9135        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9136    }
9137    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9138        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9139    }
9140    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9141        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9142    };
9143
9144    let local_var_req = local_var_req_builder.build()?;
9145    let local_var_resp = local_var_client.execute(local_var_req).await?;
9146
9147    let local_var_status = local_var_resp.status();
9148    let local_var_content = local_var_resp.text().await?;
9149
9150    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9151        serde_json::from_str(&local_var_content).map_err(Error::from)
9152    } else {
9153        let local_var_entity: Option<ListSipDomainError> = serde_json::from_str(&local_var_content).ok();
9154        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9155        Err(Error::ResponseError(local_var_error))
9156    }
9157}
9158
9159/// Retrieve a list of IpAccessControlLists that belong to the account used to make the request
9160pub async fn list_sip_ip_access_control_list(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipIpAccessControlListResponse, Error<ListSipIpAccessControlListError>> {
9161    let local_var_configuration = configuration;
9162
9163    let local_var_client = &local_var_configuration.client;
9164
9165    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9166    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9167
9168    if let Some(ref local_var_str) = page_size {
9169        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9170    }
9171    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9172        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9173    }
9174    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9175        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9176    };
9177
9178    let local_var_req = local_var_req_builder.build()?;
9179    let local_var_resp = local_var_client.execute(local_var_req).await?;
9180
9181    let local_var_status = local_var_resp.status();
9182    let local_var_content = local_var_resp.text().await?;
9183
9184    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9185        serde_json::from_str(&local_var_content).map_err(Error::from)
9186    } else {
9187        let local_var_entity: Option<ListSipIpAccessControlListError> = serde_json::from_str(&local_var_content).ok();
9188        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9189        Err(Error::ResponseError(local_var_error))
9190    }
9191}
9192
9193/// Retrieve a list of IpAccessControlListMapping resources.
9194pub async fn list_sip_ip_access_control_list_mapping(configuration: &configuration::Configuration, account_sid: &str, domain_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipIpAccessControlListMappingResponse, Error<ListSipIpAccessControlListMappingError>> {
9195    let local_var_configuration = configuration;
9196
9197    let local_var_client = &local_var_configuration.client;
9198
9199    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{DomainSid}/IpAccessControlListMappings.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), DomainSid=crate::apis::urlencode(domain_sid));
9200    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9201
9202    if let Some(ref local_var_str) = page_size {
9203        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9204    }
9205    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9206        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9207    }
9208    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9209        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9210    };
9211
9212    let local_var_req = local_var_req_builder.build()?;
9213    let local_var_resp = local_var_client.execute(local_var_req).await?;
9214
9215    let local_var_status = local_var_resp.status();
9216    let local_var_content = local_var_resp.text().await?;
9217
9218    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9219        serde_json::from_str(&local_var_content).map_err(Error::from)
9220    } else {
9221        let local_var_entity: Option<ListSipIpAccessControlListMappingError> = serde_json::from_str(&local_var_content).ok();
9222        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9223        Err(Error::ResponseError(local_var_error))
9224    }
9225}
9226
9227/// Read multiple IpAddress resources.
9228pub async fn list_sip_ip_address(configuration: &configuration::Configuration, account_sid: &str, ip_access_control_list_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListSipIpAddressResponse, Error<ListSipIpAddressError>> {
9229    let local_var_configuration = configuration;
9230
9231    let local_var_client = &local_var_configuration.client;
9232
9233    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid));
9234    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9235
9236    if let Some(ref local_var_str) = page_size {
9237        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9238    }
9239    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9240        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9241    }
9242    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9243        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9244    };
9245
9246    let local_var_req = local_var_req_builder.build()?;
9247    let local_var_resp = local_var_client.execute(local_var_req).await?;
9248
9249    let local_var_status = local_var_resp.status();
9250    let local_var_content = local_var_resp.text().await?;
9251
9252    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9253        serde_json::from_str(&local_var_content).map_err(Error::from)
9254    } else {
9255        let local_var_entity: Option<ListSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
9256        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9257        Err(Error::ResponseError(local_var_error))
9258    }
9259}
9260
9261/// Retrieve a list of transcriptions belonging to the account used to make the request
9262pub async fn list_transcription(configuration: &configuration::Configuration, account_sid: &str, page_size: Option<i32>) -> Result<crate::models::ListTranscriptionResponse, Error<ListTranscriptionError>> {
9263    let local_var_configuration = configuration;
9264
9265    let local_var_client = &local_var_configuration.client;
9266
9267    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Transcriptions.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9268    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9269
9270    if let Some(ref local_var_str) = page_size {
9271        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9272    }
9273    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9274        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9275    }
9276    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9277        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9278    };
9279
9280    let local_var_req = local_var_req_builder.build()?;
9281    let local_var_resp = local_var_client.execute(local_var_req).await?;
9282
9283    let local_var_status = local_var_resp.status();
9284    let local_var_content = local_var_resp.text().await?;
9285
9286    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9287        serde_json::from_str(&local_var_content).map_err(Error::from)
9288    } else {
9289        let local_var_entity: Option<ListTranscriptionError> = serde_json::from_str(&local_var_content).ok();
9290        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9291        Err(Error::ResponseError(local_var_error))
9292    }
9293}
9294
9295/// Retrieve a list of usage-records belonging to the account used to make the request
9296pub async fn list_usage_record(configuration: &configuration::Configuration, account_sid: &str, category: Option<&str>, start_date: Option<String>, end_date: Option<String>, include_subaccounts: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListUsageRecordResponse, Error<ListUsageRecordError>> {
9297    let local_var_configuration = configuration;
9298
9299    let local_var_client = &local_var_configuration.client;
9300
9301    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Records.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9302    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9303
9304    if let Some(ref local_var_str) = category {
9305        local_var_req_builder = local_var_req_builder.query(&[("Category", &local_var_str.to_string())]);
9306    }
9307    if let Some(ref local_var_str) = start_date {
9308        local_var_req_builder = local_var_req_builder.query(&[("StartDate", &local_var_str.to_string())]);
9309    }
9310    if let Some(ref local_var_str) = end_date {
9311        local_var_req_builder = local_var_req_builder.query(&[("EndDate", &local_var_str.to_string())]);
9312    }
9313    if let Some(ref local_var_str) = include_subaccounts {
9314        local_var_req_builder = local_var_req_builder.query(&[("IncludeSubaccounts", &local_var_str.to_string())]);
9315    }
9316    if let Some(ref local_var_str) = page_size {
9317        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9318    }
9319    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9320        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9321    }
9322    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9323        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9324    };
9325
9326    let local_var_req = local_var_req_builder.build()?;
9327    let local_var_resp = local_var_client.execute(local_var_req).await?;
9328
9329    let local_var_status = local_var_resp.status();
9330    let local_var_content = local_var_resp.text().await?;
9331
9332    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9333        serde_json::from_str(&local_var_content).map_err(Error::from)
9334    } else {
9335        let local_var_entity: Option<ListUsageRecordError> = serde_json::from_str(&local_var_content).ok();
9336        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9337        Err(Error::ResponseError(local_var_error))
9338    }
9339}
9340
9341/// 
9342pub async fn list_usage_record_all_time(configuration: &configuration::Configuration, account_sid: &str, category: Option<&str>, start_date: Option<String>, end_date: Option<String>, include_subaccounts: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListUsageRecordAllTimeResponse, Error<ListUsageRecordAllTimeError>> {
9343    let local_var_configuration = configuration;
9344
9345    let local_var_client = &local_var_configuration.client;
9346
9347    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Records/AllTime.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9348    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9349
9350    if let Some(ref local_var_str) = category {
9351        local_var_req_builder = local_var_req_builder.query(&[("Category", &local_var_str.to_string())]);
9352    }
9353    if let Some(ref local_var_str) = start_date {
9354        local_var_req_builder = local_var_req_builder.query(&[("StartDate", &local_var_str.to_string())]);
9355    }
9356    if let Some(ref local_var_str) = end_date {
9357        local_var_req_builder = local_var_req_builder.query(&[("EndDate", &local_var_str.to_string())]);
9358    }
9359    if let Some(ref local_var_str) = include_subaccounts {
9360        local_var_req_builder = local_var_req_builder.query(&[("IncludeSubaccounts", &local_var_str.to_string())]);
9361    }
9362    if let Some(ref local_var_str) = page_size {
9363        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9364    }
9365    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9366        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9367    }
9368    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9369        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9370    };
9371
9372    let local_var_req = local_var_req_builder.build()?;
9373    let local_var_resp = local_var_client.execute(local_var_req).await?;
9374
9375    let local_var_status = local_var_resp.status();
9376    let local_var_content = local_var_resp.text().await?;
9377
9378    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9379        serde_json::from_str(&local_var_content).map_err(Error::from)
9380    } else {
9381        let local_var_entity: Option<ListUsageRecordAllTimeError> = serde_json::from_str(&local_var_content).ok();
9382        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9383        Err(Error::ResponseError(local_var_error))
9384    }
9385}
9386
9387/// 
9388pub async fn list_usage_record_daily(configuration: &configuration::Configuration, account_sid: &str, category: Option<&str>, start_date: Option<String>, end_date: Option<String>, include_subaccounts: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListUsageRecordDailyResponse, Error<ListUsageRecordDailyError>> {
9389    let local_var_configuration = configuration;
9390
9391    let local_var_client = &local_var_configuration.client;
9392
9393    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Records/Daily.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9394    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9395
9396    if let Some(ref local_var_str) = category {
9397        local_var_req_builder = local_var_req_builder.query(&[("Category", &local_var_str.to_string())]);
9398    }
9399    if let Some(ref local_var_str) = start_date {
9400        local_var_req_builder = local_var_req_builder.query(&[("StartDate", &local_var_str.to_string())]);
9401    }
9402    if let Some(ref local_var_str) = end_date {
9403        local_var_req_builder = local_var_req_builder.query(&[("EndDate", &local_var_str.to_string())]);
9404    }
9405    if let Some(ref local_var_str) = include_subaccounts {
9406        local_var_req_builder = local_var_req_builder.query(&[("IncludeSubaccounts", &local_var_str.to_string())]);
9407    }
9408    if let Some(ref local_var_str) = page_size {
9409        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9410    }
9411    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9412        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9413    }
9414    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9415        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9416    };
9417
9418    let local_var_req = local_var_req_builder.build()?;
9419    let local_var_resp = local_var_client.execute(local_var_req).await?;
9420
9421    let local_var_status = local_var_resp.status();
9422    let local_var_content = local_var_resp.text().await?;
9423
9424    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9425        serde_json::from_str(&local_var_content).map_err(Error::from)
9426    } else {
9427        let local_var_entity: Option<ListUsageRecordDailyError> = serde_json::from_str(&local_var_content).ok();
9428        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9429        Err(Error::ResponseError(local_var_error))
9430    }
9431}
9432
9433/// 
9434pub async fn list_usage_record_last_month(configuration: &configuration::Configuration, account_sid: &str, category: Option<&str>, start_date: Option<String>, end_date: Option<String>, include_subaccounts: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListUsageRecordLastMonthResponse, Error<ListUsageRecordLastMonthError>> {
9435    let local_var_configuration = configuration;
9436
9437    let local_var_client = &local_var_configuration.client;
9438
9439    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Records/LastMonth.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9440    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9441
9442    if let Some(ref local_var_str) = category {
9443        local_var_req_builder = local_var_req_builder.query(&[("Category", &local_var_str.to_string())]);
9444    }
9445    if let Some(ref local_var_str) = start_date {
9446        local_var_req_builder = local_var_req_builder.query(&[("StartDate", &local_var_str.to_string())]);
9447    }
9448    if let Some(ref local_var_str) = end_date {
9449        local_var_req_builder = local_var_req_builder.query(&[("EndDate", &local_var_str.to_string())]);
9450    }
9451    if let Some(ref local_var_str) = include_subaccounts {
9452        local_var_req_builder = local_var_req_builder.query(&[("IncludeSubaccounts", &local_var_str.to_string())]);
9453    }
9454    if let Some(ref local_var_str) = page_size {
9455        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9456    }
9457    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9458        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9459    }
9460    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9461        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9462    };
9463
9464    let local_var_req = local_var_req_builder.build()?;
9465    let local_var_resp = local_var_client.execute(local_var_req).await?;
9466
9467    let local_var_status = local_var_resp.status();
9468    let local_var_content = local_var_resp.text().await?;
9469
9470    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9471        serde_json::from_str(&local_var_content).map_err(Error::from)
9472    } else {
9473        let local_var_entity: Option<ListUsageRecordLastMonthError> = serde_json::from_str(&local_var_content).ok();
9474        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9475        Err(Error::ResponseError(local_var_error))
9476    }
9477}
9478
9479/// 
9480pub async fn list_usage_record_monthly(configuration: &configuration::Configuration, account_sid: &str, category: Option<&str>, start_date: Option<String>, end_date: Option<String>, include_subaccounts: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListUsageRecordMonthlyResponse, Error<ListUsageRecordMonthlyError>> {
9481    let local_var_configuration = configuration;
9482
9483    let local_var_client = &local_var_configuration.client;
9484
9485    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Records/Monthly.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9486    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9487
9488    if let Some(ref local_var_str) = category {
9489        local_var_req_builder = local_var_req_builder.query(&[("Category", &local_var_str.to_string())]);
9490    }
9491    if let Some(ref local_var_str) = start_date {
9492        local_var_req_builder = local_var_req_builder.query(&[("StartDate", &local_var_str.to_string())]);
9493    }
9494    if let Some(ref local_var_str) = end_date {
9495        local_var_req_builder = local_var_req_builder.query(&[("EndDate", &local_var_str.to_string())]);
9496    }
9497    if let Some(ref local_var_str) = include_subaccounts {
9498        local_var_req_builder = local_var_req_builder.query(&[("IncludeSubaccounts", &local_var_str.to_string())]);
9499    }
9500    if let Some(ref local_var_str) = page_size {
9501        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9502    }
9503    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9504        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9505    }
9506    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9507        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9508    };
9509
9510    let local_var_req = local_var_req_builder.build()?;
9511    let local_var_resp = local_var_client.execute(local_var_req).await?;
9512
9513    let local_var_status = local_var_resp.status();
9514    let local_var_content = local_var_resp.text().await?;
9515
9516    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9517        serde_json::from_str(&local_var_content).map_err(Error::from)
9518    } else {
9519        let local_var_entity: Option<ListUsageRecordMonthlyError> = serde_json::from_str(&local_var_content).ok();
9520        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9521        Err(Error::ResponseError(local_var_error))
9522    }
9523}
9524
9525/// 
9526pub async fn list_usage_record_this_month(configuration: &configuration::Configuration, account_sid: &str, category: Option<&str>, start_date: Option<String>, end_date: Option<String>, include_subaccounts: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListUsageRecordThisMonthResponse, Error<ListUsageRecordThisMonthError>> {
9527    let local_var_configuration = configuration;
9528
9529    let local_var_client = &local_var_configuration.client;
9530
9531    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Records/ThisMonth.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9532    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9533
9534    if let Some(ref local_var_str) = category {
9535        local_var_req_builder = local_var_req_builder.query(&[("Category", &local_var_str.to_string())]);
9536    }
9537    if let Some(ref local_var_str) = start_date {
9538        local_var_req_builder = local_var_req_builder.query(&[("StartDate", &local_var_str.to_string())]);
9539    }
9540    if let Some(ref local_var_str) = end_date {
9541        local_var_req_builder = local_var_req_builder.query(&[("EndDate", &local_var_str.to_string())]);
9542    }
9543    if let Some(ref local_var_str) = include_subaccounts {
9544        local_var_req_builder = local_var_req_builder.query(&[("IncludeSubaccounts", &local_var_str.to_string())]);
9545    }
9546    if let Some(ref local_var_str) = page_size {
9547        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9548    }
9549    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9550        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9551    }
9552    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9553        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9554    };
9555
9556    let local_var_req = local_var_req_builder.build()?;
9557    let local_var_resp = local_var_client.execute(local_var_req).await?;
9558
9559    let local_var_status = local_var_resp.status();
9560    let local_var_content = local_var_resp.text().await?;
9561
9562    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9563        serde_json::from_str(&local_var_content).map_err(Error::from)
9564    } else {
9565        let local_var_entity: Option<ListUsageRecordThisMonthError> = serde_json::from_str(&local_var_content).ok();
9566        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9567        Err(Error::ResponseError(local_var_error))
9568    }
9569}
9570
9571/// 
9572pub async fn list_usage_record_today(configuration: &configuration::Configuration, account_sid: &str, category: Option<&str>, start_date: Option<String>, end_date: Option<String>, include_subaccounts: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListUsageRecordTodayResponse, Error<ListUsageRecordTodayError>> {
9573    let local_var_configuration = configuration;
9574
9575    let local_var_client = &local_var_configuration.client;
9576
9577    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Records/Today.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9578    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9579
9580    if let Some(ref local_var_str) = category {
9581        local_var_req_builder = local_var_req_builder.query(&[("Category", &local_var_str.to_string())]);
9582    }
9583    if let Some(ref local_var_str) = start_date {
9584        local_var_req_builder = local_var_req_builder.query(&[("StartDate", &local_var_str.to_string())]);
9585    }
9586    if let Some(ref local_var_str) = end_date {
9587        local_var_req_builder = local_var_req_builder.query(&[("EndDate", &local_var_str.to_string())]);
9588    }
9589    if let Some(ref local_var_str) = include_subaccounts {
9590        local_var_req_builder = local_var_req_builder.query(&[("IncludeSubaccounts", &local_var_str.to_string())]);
9591    }
9592    if let Some(ref local_var_str) = page_size {
9593        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9594    }
9595    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9596        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9597    }
9598    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9599        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9600    };
9601
9602    let local_var_req = local_var_req_builder.build()?;
9603    let local_var_resp = local_var_client.execute(local_var_req).await?;
9604
9605    let local_var_status = local_var_resp.status();
9606    let local_var_content = local_var_resp.text().await?;
9607
9608    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9609        serde_json::from_str(&local_var_content).map_err(Error::from)
9610    } else {
9611        let local_var_entity: Option<ListUsageRecordTodayError> = serde_json::from_str(&local_var_content).ok();
9612        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9613        Err(Error::ResponseError(local_var_error))
9614    }
9615}
9616
9617/// 
9618pub async fn list_usage_record_yearly(configuration: &configuration::Configuration, account_sid: &str, category: Option<&str>, start_date: Option<String>, end_date: Option<String>, include_subaccounts: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListUsageRecordYearlyResponse, Error<ListUsageRecordYearlyError>> {
9619    let local_var_configuration = configuration;
9620
9621    let local_var_client = &local_var_configuration.client;
9622
9623    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Records/Yearly.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9624    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9625
9626    if let Some(ref local_var_str) = category {
9627        local_var_req_builder = local_var_req_builder.query(&[("Category", &local_var_str.to_string())]);
9628    }
9629    if let Some(ref local_var_str) = start_date {
9630        local_var_req_builder = local_var_req_builder.query(&[("StartDate", &local_var_str.to_string())]);
9631    }
9632    if let Some(ref local_var_str) = end_date {
9633        local_var_req_builder = local_var_req_builder.query(&[("EndDate", &local_var_str.to_string())]);
9634    }
9635    if let Some(ref local_var_str) = include_subaccounts {
9636        local_var_req_builder = local_var_req_builder.query(&[("IncludeSubaccounts", &local_var_str.to_string())]);
9637    }
9638    if let Some(ref local_var_str) = page_size {
9639        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9640    }
9641    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9642        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9643    }
9644    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9645        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9646    };
9647
9648    let local_var_req = local_var_req_builder.build()?;
9649    let local_var_resp = local_var_client.execute(local_var_req).await?;
9650
9651    let local_var_status = local_var_resp.status();
9652    let local_var_content = local_var_resp.text().await?;
9653
9654    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9655        serde_json::from_str(&local_var_content).map_err(Error::from)
9656    } else {
9657        let local_var_entity: Option<ListUsageRecordYearlyError> = serde_json::from_str(&local_var_content).ok();
9658        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9659        Err(Error::ResponseError(local_var_error))
9660    }
9661}
9662
9663/// 
9664pub async fn list_usage_record_yesterday(configuration: &configuration::Configuration, account_sid: &str, category: Option<&str>, start_date: Option<String>, end_date: Option<String>, include_subaccounts: Option<bool>, page_size: Option<i32>) -> Result<crate::models::ListUsageRecordYesterdayResponse, Error<ListUsageRecordYesterdayError>> {
9665    let local_var_configuration = configuration;
9666
9667    let local_var_client = &local_var_configuration.client;
9668
9669    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Records/Yesterday.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9670    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9671
9672    if let Some(ref local_var_str) = category {
9673        local_var_req_builder = local_var_req_builder.query(&[("Category", &local_var_str.to_string())]);
9674    }
9675    if let Some(ref local_var_str) = start_date {
9676        local_var_req_builder = local_var_req_builder.query(&[("StartDate", &local_var_str.to_string())]);
9677    }
9678    if let Some(ref local_var_str) = end_date {
9679        local_var_req_builder = local_var_req_builder.query(&[("EndDate", &local_var_str.to_string())]);
9680    }
9681    if let Some(ref local_var_str) = include_subaccounts {
9682        local_var_req_builder = local_var_req_builder.query(&[("IncludeSubaccounts", &local_var_str.to_string())]);
9683    }
9684    if let Some(ref local_var_str) = page_size {
9685        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9686    }
9687    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9688        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9689    }
9690    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9691        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9692    };
9693
9694    let local_var_req = local_var_req_builder.build()?;
9695    let local_var_resp = local_var_client.execute(local_var_req).await?;
9696
9697    let local_var_status = local_var_resp.status();
9698    let local_var_content = local_var_resp.text().await?;
9699
9700    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9701        serde_json::from_str(&local_var_content).map_err(Error::from)
9702    } else {
9703        let local_var_entity: Option<ListUsageRecordYesterdayError> = serde_json::from_str(&local_var_content).ok();
9704        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9705        Err(Error::ResponseError(local_var_error))
9706    }
9707}
9708
9709/// Retrieve a list of usage-triggers belonging to the account used to make the request
9710pub async fn list_usage_trigger(configuration: &configuration::Configuration, account_sid: &str, recurring: Option<&str>, trigger_by: Option<&str>, usage_category: Option<&str>, page_size: Option<i32>) -> Result<crate::models::ListUsageTriggerResponse, Error<ListUsageTriggerError>> {
9711    let local_var_configuration = configuration;
9712
9713    let local_var_client = &local_var_configuration.client;
9714
9715    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Triggers.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid));
9716    let mut local_var_req_builder = local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());
9717
9718    if let Some(ref local_var_str) = recurring {
9719        local_var_req_builder = local_var_req_builder.query(&[("Recurring", &local_var_str.to_string())]);
9720    }
9721    if let Some(ref local_var_str) = trigger_by {
9722        local_var_req_builder = local_var_req_builder.query(&[("TriggerBy", &local_var_str.to_string())]);
9723    }
9724    if let Some(ref local_var_str) = usage_category {
9725        local_var_req_builder = local_var_req_builder.query(&[("UsageCategory", &local_var_str.to_string())]);
9726    }
9727    if let Some(ref local_var_str) = page_size {
9728        local_var_req_builder = local_var_req_builder.query(&[("PageSize", &local_var_str.to_string())]);
9729    }
9730    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9731        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9732    }
9733    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9734        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9735    };
9736
9737    let local_var_req = local_var_req_builder.build()?;
9738    let local_var_resp = local_var_client.execute(local_var_req).await?;
9739
9740    let local_var_status = local_var_resp.status();
9741    let local_var_content = local_var_resp.text().await?;
9742
9743    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9744        serde_json::from_str(&local_var_content).map_err(Error::from)
9745    } else {
9746        let local_var_entity: Option<ListUsageTriggerError> = serde_json::from_str(&local_var_content).ok();
9747        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9748        Err(Error::ResponseError(local_var_error))
9749    }
9750}
9751
9752/// Modify the properties of a given Account
9753pub async fn update_account(configuration: &configuration::Configuration, sid: &str, friendly_name: Option<&str>, status: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccount, Error<UpdateAccountError>> {
9754    let local_var_configuration = configuration;
9755
9756    let local_var_client = &local_var_configuration.client;
9757
9758    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{Sid}.json", local_var_configuration.base_path, Sid=crate::apis::urlencode(sid));
9759    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9760
9761    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9762        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9763    }
9764    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9765        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9766    };
9767    let mut local_var_form_params = std::collections::HashMap::new();
9768    if let Some(local_var_param_value) = friendly_name {
9769        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
9770    }
9771    if let Some(local_var_param_value) = status {
9772        local_var_form_params.insert("Status", local_var_param_value.to_string());
9773    }
9774    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
9775
9776    let local_var_req = local_var_req_builder.build()?;
9777    let local_var_resp = local_var_client.execute(local_var_req).await?;
9778
9779    let local_var_status = local_var_resp.status();
9780    let local_var_content = local_var_resp.text().await?;
9781
9782    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9783        serde_json::from_str(&local_var_content).map_err(Error::from)
9784    } else {
9785        let local_var_entity: Option<UpdateAccountError> = serde_json::from_str(&local_var_content).ok();
9786        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9787        Err(Error::ResponseError(local_var_error))
9788    }
9789}
9790
9791/// 
9792pub async fn update_address(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: Option<&str>, customer_name: Option<&str>, street: Option<&str>, city: Option<&str>, region: Option<&str>, postal_code: Option<&str>, emergency_enabled: Option<bool>, auto_correct_address: Option<bool>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodAddress, Error<UpdateAddressError>> {
9793    let local_var_configuration = configuration;
9794
9795    let local_var_client = &local_var_configuration.client;
9796
9797    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Addresses/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
9798    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9799
9800    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9801        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9802    }
9803    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9804        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9805    };
9806    let mut local_var_form_params = std::collections::HashMap::new();
9807    if let Some(local_var_param_value) = friendly_name {
9808        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
9809    }
9810    if let Some(local_var_param_value) = customer_name {
9811        local_var_form_params.insert("CustomerName", local_var_param_value.to_string());
9812    }
9813    if let Some(local_var_param_value) = street {
9814        local_var_form_params.insert("Street", local_var_param_value.to_string());
9815    }
9816    if let Some(local_var_param_value) = city {
9817        local_var_form_params.insert("City", local_var_param_value.to_string());
9818    }
9819    if let Some(local_var_param_value) = region {
9820        local_var_form_params.insert("Region", local_var_param_value.to_string());
9821    }
9822    if let Some(local_var_param_value) = postal_code {
9823        local_var_form_params.insert("PostalCode", local_var_param_value.to_string());
9824    }
9825    if let Some(local_var_param_value) = emergency_enabled {
9826        local_var_form_params.insert("EmergencyEnabled", local_var_param_value.to_string());
9827    }
9828    if let Some(local_var_param_value) = auto_correct_address {
9829        local_var_form_params.insert("AutoCorrectAddress", local_var_param_value.to_string());
9830    }
9831    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
9832
9833    let local_var_req = local_var_req_builder.build()?;
9834    let local_var_resp = local_var_client.execute(local_var_req).await?;
9835
9836    let local_var_status = local_var_resp.status();
9837    let local_var_content = local_var_resp.text().await?;
9838
9839    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9840        serde_json::from_str(&local_var_content).map_err(Error::from)
9841    } else {
9842        let local_var_entity: Option<UpdateAddressError> = serde_json::from_str(&local_var_content).ok();
9843        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9844        Err(Error::ResponseError(local_var_error))
9845    }
9846}
9847
9848/// Updates the application's properties
9849pub async fn update_application(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: Option<&str>, api_version: Option<&str>, voice_url: Option<&str>, voice_method: Option<&str>, voice_fallback_url: Option<&str>, voice_fallback_method: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, voice_caller_id_lookup: Option<bool>, sms_url: Option<&str>, sms_method: Option<&str>, sms_fallback_url: Option<&str>, sms_fallback_method: Option<&str>, sms_status_callback: Option<&str>, message_status_callback: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodApplication, Error<UpdateApplicationError>> {
9850    let local_var_configuration = configuration;
9851
9852    let local_var_client = &local_var_configuration.client;
9853
9854    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Applications/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
9855    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9856
9857    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9858        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9859    }
9860    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9861        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9862    };
9863    let mut local_var_form_params = std::collections::HashMap::new();
9864    if let Some(local_var_param_value) = friendly_name {
9865        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
9866    }
9867    if let Some(local_var_param_value) = api_version {
9868        local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
9869    }
9870    if let Some(local_var_param_value) = voice_url {
9871        local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
9872    }
9873    if let Some(local_var_param_value) = voice_method {
9874        local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
9875    }
9876    if let Some(local_var_param_value) = voice_fallback_url {
9877        local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
9878    }
9879    if let Some(local_var_param_value) = voice_fallback_method {
9880        local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
9881    }
9882    if let Some(local_var_param_value) = status_callback {
9883        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
9884    }
9885    if let Some(local_var_param_value) = status_callback_method {
9886        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
9887    }
9888    if let Some(local_var_param_value) = voice_caller_id_lookup {
9889        local_var_form_params.insert("VoiceCallerIdLookup", local_var_param_value.to_string());
9890    }
9891    if let Some(local_var_param_value) = sms_url {
9892        local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
9893    }
9894    if let Some(local_var_param_value) = sms_method {
9895        local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
9896    }
9897    if let Some(local_var_param_value) = sms_fallback_url {
9898        local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
9899    }
9900    if let Some(local_var_param_value) = sms_fallback_method {
9901        local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
9902    }
9903    if let Some(local_var_param_value) = sms_status_callback {
9904        local_var_form_params.insert("SmsStatusCallback", local_var_param_value.to_string());
9905    }
9906    if let Some(local_var_param_value) = message_status_callback {
9907        local_var_form_params.insert("MessageStatusCallback", local_var_param_value.to_string());
9908    }
9909    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
9910
9911    let local_var_req = local_var_req_builder.build()?;
9912    let local_var_resp = local_var_client.execute(local_var_req).await?;
9913
9914    let local_var_status = local_var_resp.status();
9915    let local_var_content = local_var_resp.text().await?;
9916
9917    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9918        serde_json::from_str(&local_var_content).map_err(Error::from)
9919    } else {
9920        let local_var_entity: Option<UpdateApplicationError> = serde_json::from_str(&local_var_content).ok();
9921        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9922        Err(Error::ResponseError(local_var_error))
9923    }
9924}
9925
9926/// Initiates a call redirect or terminates a call
9927pub async fn update_call(configuration: &configuration::Configuration, account_sid: &str, sid: &str, url: Option<&str>, method: Option<&str>, status: Option<&str>, fallback_url: Option<&str>, fallback_method: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, twiml: Option<&str>, time_limit: Option<i32>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCall, Error<UpdateCallError>> {
9928    let local_var_configuration = configuration;
9929
9930    let local_var_client = &local_var_configuration.client;
9931
9932    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
9933    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9934
9935    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9936        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9937    }
9938    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9939        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
9940    };
9941    let mut local_var_form_params = std::collections::HashMap::new();
9942    if let Some(local_var_param_value) = url {
9943        local_var_form_params.insert("Url", local_var_param_value.to_string());
9944    }
9945    if let Some(local_var_param_value) = method {
9946        local_var_form_params.insert("Method", local_var_param_value.to_string());
9947    }
9948    if let Some(local_var_param_value) = status {
9949        local_var_form_params.insert("Status", local_var_param_value.to_string());
9950    }
9951    if let Some(local_var_param_value) = fallback_url {
9952        local_var_form_params.insert("FallbackUrl", local_var_param_value.to_string());
9953    }
9954    if let Some(local_var_param_value) = fallback_method {
9955        local_var_form_params.insert("FallbackMethod", local_var_param_value.to_string());
9956    }
9957    if let Some(local_var_param_value) = status_callback {
9958        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
9959    }
9960    if let Some(local_var_param_value) = status_callback_method {
9961        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
9962    }
9963    if let Some(local_var_param_value) = twiml {
9964        local_var_form_params.insert("Twiml", local_var_param_value.to_string());
9965    }
9966    if let Some(local_var_param_value) = time_limit {
9967        local_var_form_params.insert("TimeLimit", local_var_param_value.to_string());
9968    }
9969    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
9970
9971    let local_var_req = local_var_req_builder.build()?;
9972    let local_var_resp = local_var_client.execute(local_var_req).await?;
9973
9974    let local_var_status = local_var_resp.status();
9975    let local_var_content = local_var_resp.text().await?;
9976
9977    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
9978        serde_json::from_str(&local_var_content).map_err(Error::from)
9979    } else {
9980        let local_var_entity: Option<UpdateCallError> = serde_json::from_str(&local_var_content).ok();
9981        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
9982        Err(Error::ResponseError(local_var_error))
9983    }
9984}
9985
9986/// Update a Feedback resource for a call
9987pub async fn update_call_feedback(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, quality_score: Option<i32>, issue: Option<Vec<crate::models::CallFeedbackEnumIssues>>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodCallFeedback, Error<UpdateCallFeedbackError>> {
9988    let local_var_configuration = configuration;
9989
9990    let local_var_client = &local_var_configuration.client;
9991
9992    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Feedback.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid));
9993    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
9994
9995    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
9996        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
9997    }
9998    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
9999        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10000    };
10001    let mut local_var_form_params = std::collections::HashMap::new();
10002    if let Some(local_var_param_value) = quality_score {
10003        local_var_form_params.insert("QualityScore", local_var_param_value.to_string());
10004    }
10005    if let Some(local_var_param_value) = issue {
10006        local_var_form_params.insert("Issue", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
10007    }
10008    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10009
10010    let local_var_req = local_var_req_builder.build()?;
10011    let local_var_resp = local_var_client.execute(local_var_req).await?;
10012
10013    let local_var_status = local_var_resp.status();
10014    let local_var_content = local_var_resp.text().await?;
10015
10016    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10017        serde_json::from_str(&local_var_content).map_err(Error::from)
10018    } else {
10019        let local_var_entity: Option<UpdateCallFeedbackError> = serde_json::from_str(&local_var_content).ok();
10020        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10021        Err(Error::ResponseError(local_var_error))
10022    }
10023}
10024
10025/// Changes the status of the recording to paused, stopped, or in-progress. Note: Pass `Twilio.CURRENT` instead of recording sid to reference current active recording.
10026pub async fn update_call_recording(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, sid: &str, status: &str, pause_behavior: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodCallRecording, Error<UpdateCallRecordingError>> {
10027    let local_var_configuration = configuration;
10028
10029    let local_var_client = &local_var_configuration.client;
10030
10031    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Recordings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid), Sid=crate::apis::urlencode(sid));
10032    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10033
10034    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10035        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10036    }
10037    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10038        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10039    };
10040    let mut local_var_form_params = std::collections::HashMap::new();
10041    local_var_form_params.insert("Status", status.to_string());
10042    if let Some(local_var_param_value) = pause_behavior {
10043        local_var_form_params.insert("PauseBehavior", local_var_param_value.to_string());
10044    }
10045    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10046
10047    let local_var_req = local_var_req_builder.build()?;
10048    let local_var_resp = local_var_client.execute(local_var_req).await?;
10049
10050    let local_var_status = local_var_resp.status();
10051    let local_var_content = local_var_resp.text().await?;
10052
10053    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10054        serde_json::from_str(&local_var_content).map_err(Error::from)
10055    } else {
10056        let local_var_entity: Option<UpdateCallRecordingError> = serde_json::from_str(&local_var_content).ok();
10057        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10058        Err(Error::ResponseError(local_var_error))
10059    }
10060}
10061
10062/// 
10063pub async fn update_conference(configuration: &configuration::Configuration, account_sid: &str, sid: &str, status: Option<&str>, announce_url: Option<&str>, announce_method: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodConference, Error<UpdateConferenceError>> {
10064    let local_var_configuration = configuration;
10065
10066    let local_var_client = &local_var_configuration.client;
10067
10068    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10069    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10070
10071    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10072        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10073    }
10074    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10075        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10076    };
10077    let mut local_var_form_params = std::collections::HashMap::new();
10078    if let Some(local_var_param_value) = status {
10079        local_var_form_params.insert("Status", local_var_param_value.to_string());
10080    }
10081    if let Some(local_var_param_value) = announce_url {
10082        local_var_form_params.insert("AnnounceUrl", local_var_param_value.to_string());
10083    }
10084    if let Some(local_var_param_value) = announce_method {
10085        local_var_form_params.insert("AnnounceMethod", local_var_param_value.to_string());
10086    }
10087    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10088
10089    let local_var_req = local_var_req_builder.build()?;
10090    let local_var_resp = local_var_client.execute(local_var_req).await?;
10091
10092    let local_var_status = local_var_resp.status();
10093    let local_var_content = local_var_resp.text().await?;
10094
10095    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10096        serde_json::from_str(&local_var_content).map_err(Error::from)
10097    } else {
10098        let local_var_entity: Option<UpdateConferenceError> = serde_json::from_str(&local_var_content).ok();
10099        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10100        Err(Error::ResponseError(local_var_error))
10101    }
10102}
10103
10104/// Changes the status of the recording to paused, stopped, or in-progress. Note: To use `Twilio.CURRENT`, pass it as recording sid.
10105pub async fn update_conference_recording(configuration: &configuration::Configuration, account_sid: &str, conference_sid: &str, sid: &str, status: &str, pause_behavior: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodConferencePeriodConferenceRecording, Error<UpdateConferenceRecordingError>> {
10106    let local_var_configuration = configuration;
10107
10108    let local_var_client = &local_var_configuration.client;
10109
10110    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{ConferenceSid}/Recordings/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConferenceSid=crate::apis::urlencode(conference_sid), Sid=crate::apis::urlencode(sid));
10111    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10112
10113    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10114        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10115    }
10116    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10117        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10118    };
10119    let mut local_var_form_params = std::collections::HashMap::new();
10120    local_var_form_params.insert("Status", status.to_string());
10121    if let Some(local_var_param_value) = pause_behavior {
10122        local_var_form_params.insert("PauseBehavior", local_var_param_value.to_string());
10123    }
10124    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10125
10126    let local_var_req = local_var_req_builder.build()?;
10127    let local_var_resp = local_var_client.execute(local_var_req).await?;
10128
10129    let local_var_status = local_var_resp.status();
10130    let local_var_content = local_var_resp.text().await?;
10131
10132    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10133        serde_json::from_str(&local_var_content).map_err(Error::from)
10134    } else {
10135        let local_var_entity: Option<UpdateConferenceRecordingError> = serde_json::from_str(&local_var_content).ok();
10136        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10137        Err(Error::ResponseError(local_var_error))
10138    }
10139}
10140
10141/// Update a connect-app with the specified parameters
10142pub async fn update_connect_app(configuration: &configuration::Configuration, account_sid: &str, sid: &str, authorize_redirect_url: Option<&str>, company_name: Option<&str>, deauthorize_callback_method: Option<&str>, deauthorize_callback_url: Option<&str>, description: Option<&str>, friendly_name: Option<&str>, homepage_url: Option<&str>, permissions: Option<Vec<crate::models::ConnectAppEnumPermission>>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodConnectApp, Error<UpdateConnectAppError>> {
10143    let local_var_configuration = configuration;
10144
10145    let local_var_client = &local_var_configuration.client;
10146
10147    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/ConnectApps/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10148    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10149
10150    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10151        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10152    }
10153    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10154        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10155    };
10156    let mut local_var_form_params = std::collections::HashMap::new();
10157    if let Some(local_var_param_value) = authorize_redirect_url {
10158        local_var_form_params.insert("AuthorizeRedirectUrl", local_var_param_value.to_string());
10159    }
10160    if let Some(local_var_param_value) = company_name {
10161        local_var_form_params.insert("CompanyName", local_var_param_value.to_string());
10162    }
10163    if let Some(local_var_param_value) = deauthorize_callback_method {
10164        local_var_form_params.insert("DeauthorizeCallbackMethod", local_var_param_value.to_string());
10165    }
10166    if let Some(local_var_param_value) = deauthorize_callback_url {
10167        local_var_form_params.insert("DeauthorizeCallbackUrl", local_var_param_value.to_string());
10168    }
10169    if let Some(local_var_param_value) = description {
10170        local_var_form_params.insert("Description", local_var_param_value.to_string());
10171    }
10172    if let Some(local_var_param_value) = friendly_name {
10173        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10174    }
10175    if let Some(local_var_param_value) = homepage_url {
10176        local_var_form_params.insert("HomepageUrl", local_var_param_value.to_string());
10177    }
10178    if let Some(local_var_param_value) = permissions {
10179        local_var_form_params.insert("Permissions", local_var_param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string());
10180    }
10181    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10182
10183    let local_var_req = local_var_req_builder.build()?;
10184    let local_var_resp = local_var_client.execute(local_var_req).await?;
10185
10186    let local_var_status = local_var_resp.status();
10187    let local_var_content = local_var_resp.text().await?;
10188
10189    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10190        serde_json::from_str(&local_var_content).map_err(Error::from)
10191    } else {
10192        let local_var_entity: Option<UpdateConnectAppError> = serde_json::from_str(&local_var_content).ok();
10193        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10194        Err(Error::ResponseError(local_var_error))
10195    }
10196}
10197
10198/// Update an incoming-phone-number instance.
10199pub async fn update_incoming_phone_number(configuration: &configuration::Configuration, account_sid: &str, sid: &str, account_sid2: Option<&str>, api_version: Option<&str>, friendly_name: Option<&str>, sms_application_sid: Option<&str>, sms_fallback_method: Option<&str>, sms_fallback_url: Option<&str>, sms_method: Option<&str>, sms_url: Option<&str>, status_callback: Option<&str>, status_callback_method: Option<&str>, voice_application_sid: Option<&str>, voice_caller_id_lookup: Option<bool>, voice_fallback_method: Option<&str>, voice_fallback_url: Option<&str>, voice_method: Option<&str>, voice_url: Option<&str>, emergency_status: Option<&str>, emergency_address_sid: Option<&str>, trunk_sid: Option<&str>, voice_receive_mode: Option<&str>, identity_sid: Option<&str>, address_sid: Option<&str>, bundle_sid: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodIncomingPhoneNumber, Error<UpdateIncomingPhoneNumberError>> {
10200    let local_var_configuration = configuration;
10201
10202    let local_var_client = &local_var_configuration.client;
10203
10204    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/IncomingPhoneNumbers/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10205    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10206
10207    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10208        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10209    }
10210    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10211        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10212    };
10213    let mut local_var_form_params = std::collections::HashMap::new();
10214    if let Some(local_var_param_value) = account_sid2 {
10215        local_var_form_params.insert("AccountSid", local_var_param_value.to_string());
10216    }
10217    if let Some(local_var_param_value) = api_version {
10218        local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
10219    }
10220    if let Some(local_var_param_value) = friendly_name {
10221        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10222    }
10223    if let Some(local_var_param_value) = sms_application_sid {
10224        local_var_form_params.insert("SmsApplicationSid", local_var_param_value.to_string());
10225    }
10226    if let Some(local_var_param_value) = sms_fallback_method {
10227        local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
10228    }
10229    if let Some(local_var_param_value) = sms_fallback_url {
10230        local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
10231    }
10232    if let Some(local_var_param_value) = sms_method {
10233        local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
10234    }
10235    if let Some(local_var_param_value) = sms_url {
10236        local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
10237    }
10238    if let Some(local_var_param_value) = status_callback {
10239        local_var_form_params.insert("StatusCallback", local_var_param_value.to_string());
10240    }
10241    if let Some(local_var_param_value) = status_callback_method {
10242        local_var_form_params.insert("StatusCallbackMethod", local_var_param_value.to_string());
10243    }
10244    if let Some(local_var_param_value) = voice_application_sid {
10245        local_var_form_params.insert("VoiceApplicationSid", local_var_param_value.to_string());
10246    }
10247    if let Some(local_var_param_value) = voice_caller_id_lookup {
10248        local_var_form_params.insert("VoiceCallerIdLookup", local_var_param_value.to_string());
10249    }
10250    if let Some(local_var_param_value) = voice_fallback_method {
10251        local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
10252    }
10253    if let Some(local_var_param_value) = voice_fallback_url {
10254        local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
10255    }
10256    if let Some(local_var_param_value) = voice_method {
10257        local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
10258    }
10259    if let Some(local_var_param_value) = voice_url {
10260        local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
10261    }
10262    if let Some(local_var_param_value) = emergency_status {
10263        local_var_form_params.insert("EmergencyStatus", local_var_param_value.to_string());
10264    }
10265    if let Some(local_var_param_value) = emergency_address_sid {
10266        local_var_form_params.insert("EmergencyAddressSid", local_var_param_value.to_string());
10267    }
10268    if let Some(local_var_param_value) = trunk_sid {
10269        local_var_form_params.insert("TrunkSid", local_var_param_value.to_string());
10270    }
10271    if let Some(local_var_param_value) = voice_receive_mode {
10272        local_var_form_params.insert("VoiceReceiveMode", local_var_param_value.to_string());
10273    }
10274    if let Some(local_var_param_value) = identity_sid {
10275        local_var_form_params.insert("IdentitySid", local_var_param_value.to_string());
10276    }
10277    if let Some(local_var_param_value) = address_sid {
10278        local_var_form_params.insert("AddressSid", local_var_param_value.to_string());
10279    }
10280    if let Some(local_var_param_value) = bundle_sid {
10281        local_var_form_params.insert("BundleSid", local_var_param_value.to_string());
10282    }
10283    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10284
10285    let local_var_req = local_var_req_builder.build()?;
10286    let local_var_resp = local_var_client.execute(local_var_req).await?;
10287
10288    let local_var_status = local_var_resp.status();
10289    let local_var_content = local_var_resp.text().await?;
10290
10291    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10292        serde_json::from_str(&local_var_content).map_err(Error::from)
10293    } else {
10294        let local_var_entity: Option<UpdateIncomingPhoneNumberError> = serde_json::from_str(&local_var_content).ok();
10295        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10296        Err(Error::ResponseError(local_var_error))
10297    }
10298}
10299
10300/// 
10301pub async fn update_key(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodKey, Error<UpdateKeyError>> {
10302    let local_var_configuration = configuration;
10303
10304    let local_var_client = &local_var_configuration.client;
10305
10306    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Keys/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10307    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10308
10309    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10310        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10311    }
10312    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10313        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10314    };
10315    let mut local_var_form_params = std::collections::HashMap::new();
10316    if let Some(local_var_param_value) = friendly_name {
10317        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10318    }
10319    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10320
10321    let local_var_req = local_var_req_builder.build()?;
10322    let local_var_resp = local_var_client.execute(local_var_req).await?;
10323
10324    let local_var_status = local_var_resp.status();
10325    let local_var_content = local_var_resp.text().await?;
10326
10327    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10328        serde_json::from_str(&local_var_content).map_err(Error::from)
10329    } else {
10330        let local_var_entity: Option<UpdateKeyError> = serde_json::from_str(&local_var_content).ok();
10331        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10332        Err(Error::ResponseError(local_var_error))
10333    }
10334}
10335
10336/// Dequeue a member from a queue and have the member's call begin executing the TwiML document at that URL
10337pub async fn update_member(configuration: &configuration::Configuration, account_sid: &str, queue_sid: &str, call_sid: &str, url: &str, method: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodQueuePeriodMember, Error<UpdateMemberError>> {
10338    let local_var_configuration = configuration;
10339
10340    let local_var_client = &local_var_configuration.client;
10341
10342    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Queues/{QueueSid}/Members/{CallSid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), QueueSid=crate::apis::urlencode(queue_sid), CallSid=crate::apis::urlencode(call_sid));
10343    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10344
10345    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10346        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10347    }
10348    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10349        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10350    };
10351    let mut local_var_form_params = std::collections::HashMap::new();
10352    local_var_form_params.insert("Url", url.to_string());
10353    if let Some(local_var_param_value) = method {
10354        local_var_form_params.insert("Method", local_var_param_value.to_string());
10355    }
10356    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10357
10358    let local_var_req = local_var_req_builder.build()?;
10359    let local_var_resp = local_var_client.execute(local_var_req).await?;
10360
10361    let local_var_status = local_var_resp.status();
10362    let local_var_content = local_var_resp.text().await?;
10363
10364    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10365        serde_json::from_str(&local_var_content).map_err(Error::from)
10366    } else {
10367        let local_var_entity: Option<UpdateMemberError> = serde_json::from_str(&local_var_content).ok();
10368        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10369        Err(Error::ResponseError(local_var_error))
10370    }
10371}
10372
10373/// To redact a message-body from a post-flight message record, post to the message instance resource with an empty body
10374pub async fn update_message(configuration: &configuration::Configuration, account_sid: &str, sid: &str, body: Option<&str>, status: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodMessage, Error<UpdateMessageError>> {
10375    let local_var_configuration = configuration;
10376
10377    let local_var_client = &local_var_configuration.client;
10378
10379    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Messages/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10380    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10381
10382    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10383        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10384    }
10385    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10386        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10387    };
10388    let mut local_var_form_params = std::collections::HashMap::new();
10389    if let Some(local_var_param_value) = body {
10390        local_var_form_params.insert("Body", local_var_param_value.to_string());
10391    }
10392    if let Some(local_var_param_value) = status {
10393        local_var_form_params.insert("Status", local_var_param_value.to_string());
10394    }
10395    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10396
10397    let local_var_req = local_var_req_builder.build()?;
10398    let local_var_resp = local_var_client.execute(local_var_req).await?;
10399
10400    let local_var_status = local_var_resp.status();
10401    let local_var_content = local_var_resp.text().await?;
10402
10403    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10404        serde_json::from_str(&local_var_content).map_err(Error::from)
10405    } else {
10406        let local_var_entity: Option<UpdateMessageError> = serde_json::from_str(&local_var_content).ok();
10407        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10408        Err(Error::ResponseError(local_var_error))
10409    }
10410}
10411
10412/// Updates the caller-id
10413pub async fn update_outgoing_caller_id(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodOutgoingCallerId, Error<UpdateOutgoingCallerIdError>> {
10414    let local_var_configuration = configuration;
10415
10416    let local_var_client = &local_var_configuration.client;
10417
10418    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/OutgoingCallerIds/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10419    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10420
10421    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10422        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10423    }
10424    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10425        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10426    };
10427    let mut local_var_form_params = std::collections::HashMap::new();
10428    if let Some(local_var_param_value) = friendly_name {
10429        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10430    }
10431    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10432
10433    let local_var_req = local_var_req_builder.build()?;
10434    let local_var_resp = local_var_client.execute(local_var_req).await?;
10435
10436    let local_var_status = local_var_resp.status();
10437    let local_var_content = local_var_resp.text().await?;
10438
10439    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10440        serde_json::from_str(&local_var_content).map_err(Error::from)
10441    } else {
10442        let local_var_entity: Option<UpdateOutgoingCallerIdError> = serde_json::from_str(&local_var_content).ok();
10443        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10444        Err(Error::ResponseError(local_var_error))
10445    }
10446}
10447
10448/// Update the properties of the participant
10449pub async fn update_participant(configuration: &configuration::Configuration, account_sid: &str, conference_sid: &str, call_sid: &str, muted: Option<bool>, hold: Option<bool>, hold_url: Option<&str>, hold_method: Option<&str>, announce_url: Option<&str>, announce_method: Option<&str>, wait_url: Option<&str>, wait_method: Option<&str>, beep_on_exit: Option<bool>, end_conference_on_exit: Option<bool>, coaching: Option<bool>, call_sid_to_coach: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodConferencePeriodParticipant, Error<UpdateParticipantError>> {
10450    let local_var_configuration = configuration;
10451
10452    let local_var_client = &local_var_configuration.client;
10453
10454    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Conferences/{ConferenceSid}/Participants/{CallSid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), ConferenceSid=crate::apis::urlencode(conference_sid), CallSid=crate::apis::urlencode(call_sid));
10455    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10456
10457    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10458        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10459    }
10460    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10461        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10462    };
10463    let mut local_var_form_params = std::collections::HashMap::new();
10464    if let Some(local_var_param_value) = muted {
10465        local_var_form_params.insert("Muted", local_var_param_value.to_string());
10466    }
10467    if let Some(local_var_param_value) = hold {
10468        local_var_form_params.insert("Hold", local_var_param_value.to_string());
10469    }
10470    if let Some(local_var_param_value) = hold_url {
10471        local_var_form_params.insert("HoldUrl", local_var_param_value.to_string());
10472    }
10473    if let Some(local_var_param_value) = hold_method {
10474        local_var_form_params.insert("HoldMethod", local_var_param_value.to_string());
10475    }
10476    if let Some(local_var_param_value) = announce_url {
10477        local_var_form_params.insert("AnnounceUrl", local_var_param_value.to_string());
10478    }
10479    if let Some(local_var_param_value) = announce_method {
10480        local_var_form_params.insert("AnnounceMethod", local_var_param_value.to_string());
10481    }
10482    if let Some(local_var_param_value) = wait_url {
10483        local_var_form_params.insert("WaitUrl", local_var_param_value.to_string());
10484    }
10485    if let Some(local_var_param_value) = wait_method {
10486        local_var_form_params.insert("WaitMethod", local_var_param_value.to_string());
10487    }
10488    if let Some(local_var_param_value) = beep_on_exit {
10489        local_var_form_params.insert("BeepOnExit", local_var_param_value.to_string());
10490    }
10491    if let Some(local_var_param_value) = end_conference_on_exit {
10492        local_var_form_params.insert("EndConferenceOnExit", local_var_param_value.to_string());
10493    }
10494    if let Some(local_var_param_value) = coaching {
10495        local_var_form_params.insert("Coaching", local_var_param_value.to_string());
10496    }
10497    if let Some(local_var_param_value) = call_sid_to_coach {
10498        local_var_form_params.insert("CallSidToCoach", local_var_param_value.to_string());
10499    }
10500    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10501
10502    let local_var_req = local_var_req_builder.build()?;
10503    let local_var_resp = local_var_client.execute(local_var_req).await?;
10504
10505    let local_var_status = local_var_resp.status();
10506    let local_var_content = local_var_resp.text().await?;
10507
10508    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10509        serde_json::from_str(&local_var_content).map_err(Error::from)
10510    } else {
10511        let local_var_entity: Option<UpdateParticipantError> = serde_json::from_str(&local_var_content).ok();
10512        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10513        Err(Error::ResponseError(local_var_error))
10514    }
10515}
10516
10517/// update an instance of payments with different phases of payment flows.
10518pub async fn update_payments(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, sid: &str, idempotency_key: &str, status_callback: &str, capture: Option<&str>, status: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodPayments, Error<UpdatePaymentsError>> {
10519    let local_var_configuration = configuration;
10520
10521    let local_var_client = &local_var_configuration.client;
10522
10523    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Payments/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid), Sid=crate::apis::urlencode(sid));
10524    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10525
10526    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10527        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10528    }
10529    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10530        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10531    };
10532    let mut local_var_form_params = std::collections::HashMap::new();
10533    local_var_form_params.insert("IdempotencyKey", idempotency_key.to_string());
10534    local_var_form_params.insert("StatusCallback", status_callback.to_string());
10535    if let Some(local_var_param_value) = capture {
10536        local_var_form_params.insert("Capture", local_var_param_value.to_string());
10537    }
10538    if let Some(local_var_param_value) = status {
10539        local_var_form_params.insert("Status", local_var_param_value.to_string());
10540    }
10541    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10542
10543    let local_var_req = local_var_req_builder.build()?;
10544    let local_var_resp = local_var_client.execute(local_var_req).await?;
10545
10546    let local_var_status = local_var_resp.status();
10547    let local_var_content = local_var_resp.text().await?;
10548
10549    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10550        serde_json::from_str(&local_var_content).map_err(Error::from)
10551    } else {
10552        let local_var_entity: Option<UpdatePaymentsError> = serde_json::from_str(&local_var_content).ok();
10553        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10554        Err(Error::ResponseError(local_var_error))
10555    }
10556}
10557
10558/// Update the queue with the new parameters
10559pub async fn update_queue(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: Option<&str>, max_size: Option<i32>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodQueue, Error<UpdateQueueError>> {
10560    let local_var_configuration = configuration;
10561
10562    let local_var_client = &local_var_configuration.client;
10563
10564    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Queues/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10565    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10566
10567    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10568        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10569    }
10570    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10571        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10572    };
10573    let mut local_var_form_params = std::collections::HashMap::new();
10574    if let Some(local_var_param_value) = friendly_name {
10575        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10576    }
10577    if let Some(local_var_param_value) = max_size {
10578        local_var_form_params.insert("MaxSize", local_var_param_value.to_string());
10579    }
10580    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10581
10582    let local_var_req = local_var_req_builder.build()?;
10583    let local_var_resp = local_var_client.execute(local_var_req).await?;
10584
10585    let local_var_status = local_var_resp.status();
10586    let local_var_content = local_var_resp.text().await?;
10587
10588    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10589        serde_json::from_str(&local_var_content).map_err(Error::from)
10590    } else {
10591        let local_var_entity: Option<UpdateQueueError> = serde_json::from_str(&local_var_content).ok();
10592        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10593        Err(Error::ResponseError(local_var_error))
10594    }
10595}
10596
10597/// Update a short code with the following parameters
10598pub async fn update_short_code(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: Option<&str>, api_version: Option<&str>, sms_url: Option<&str>, sms_method: Option<&str>, sms_fallback_url: Option<&str>, sms_fallback_method: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodShortCode, Error<UpdateShortCodeError>> {
10599    let local_var_configuration = configuration;
10600
10601    let local_var_client = &local_var_configuration.client;
10602
10603    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SMS/ShortCodes/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10604    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10605
10606    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10607        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10608    }
10609    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10610        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10611    };
10612    let mut local_var_form_params = std::collections::HashMap::new();
10613    if let Some(local_var_param_value) = friendly_name {
10614        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10615    }
10616    if let Some(local_var_param_value) = api_version {
10617        local_var_form_params.insert("ApiVersion", local_var_param_value.to_string());
10618    }
10619    if let Some(local_var_param_value) = sms_url {
10620        local_var_form_params.insert("SmsUrl", local_var_param_value.to_string());
10621    }
10622    if let Some(local_var_param_value) = sms_method {
10623        local_var_form_params.insert("SmsMethod", local_var_param_value.to_string());
10624    }
10625    if let Some(local_var_param_value) = sms_fallback_url {
10626        local_var_form_params.insert("SmsFallbackUrl", local_var_param_value.to_string());
10627    }
10628    if let Some(local_var_param_value) = sms_fallback_method {
10629        local_var_form_params.insert("SmsFallbackMethod", local_var_param_value.to_string());
10630    }
10631    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10632
10633    let local_var_req = local_var_req_builder.build()?;
10634    let local_var_resp = local_var_client.execute(local_var_req).await?;
10635
10636    let local_var_status = local_var_resp.status();
10637    let local_var_content = local_var_resp.text().await?;
10638
10639    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10640        serde_json::from_str(&local_var_content).map_err(Error::from)
10641    } else {
10642        let local_var_entity: Option<UpdateShortCodeError> = serde_json::from_str(&local_var_content).ok();
10643        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10644        Err(Error::ResponseError(local_var_error))
10645    }
10646}
10647
10648/// 
10649pub async fn update_signing_key(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSigningKey, Error<UpdateSigningKeyError>> {
10650    let local_var_configuration = configuration;
10651
10652    let local_var_client = &local_var_configuration.client;
10653
10654    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SigningKeys/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10655    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10656
10657    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10658        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10659    }
10660    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10661        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10662    };
10663    let mut local_var_form_params = std::collections::HashMap::new();
10664    if let Some(local_var_param_value) = friendly_name {
10665        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10666    }
10667    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10668
10669    let local_var_req = local_var_req_builder.build()?;
10670    let local_var_resp = local_var_client.execute(local_var_req).await?;
10671
10672    let local_var_status = local_var_resp.status();
10673    let local_var_content = local_var_resp.text().await?;
10674
10675    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10676        serde_json::from_str(&local_var_content).map_err(Error::from)
10677    } else {
10678        let local_var_entity: Option<UpdateSigningKeyError> = serde_json::from_str(&local_var_content).ok();
10679        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10680        Err(Error::ResponseError(local_var_error))
10681    }
10682}
10683
10684/// Update a credential resource.
10685pub async fn update_sip_credential(configuration: &configuration::Configuration, account_sid: &str, credential_list_sid: &str, sid: &str, password: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipCredentialListPeriodSipCredential, Error<UpdateSipCredentialError>> {
10686    let local_var_configuration = configuration;
10687
10688    let local_var_client = &local_var_configuration.client;
10689
10690    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists/{CredentialListSid}/Credentials/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CredentialListSid=crate::apis::urlencode(credential_list_sid), Sid=crate::apis::urlencode(sid));
10691    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10692
10693    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10694        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10695    }
10696    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10697        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10698    };
10699    let mut local_var_form_params = std::collections::HashMap::new();
10700    if let Some(local_var_param_value) = password {
10701        local_var_form_params.insert("Password", local_var_param_value.to_string());
10702    }
10703    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10704
10705    let local_var_req = local_var_req_builder.build()?;
10706    let local_var_resp = local_var_client.execute(local_var_req).await?;
10707
10708    let local_var_status = local_var_resp.status();
10709    let local_var_content = local_var_resp.text().await?;
10710
10711    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10712        serde_json::from_str(&local_var_content).map_err(Error::from)
10713    } else {
10714        let local_var_entity: Option<UpdateSipCredentialError> = serde_json::from_str(&local_var_content).ok();
10715        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10716        Err(Error::ResponseError(local_var_error))
10717    }
10718}
10719
10720/// Update a Credential List
10721pub async fn update_sip_credential_list(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipCredentialList, Error<UpdateSipCredentialListError>> {
10722    let local_var_configuration = configuration;
10723
10724    let local_var_client = &local_var_configuration.client;
10725
10726    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/CredentialLists/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10727    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10728
10729    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10730        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10731    }
10732    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10733        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10734    };
10735    let mut local_var_form_params = std::collections::HashMap::new();
10736    local_var_form_params.insert("FriendlyName", friendly_name.to_string());
10737    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10738
10739    let local_var_req = local_var_req_builder.build()?;
10740    let local_var_resp = local_var_client.execute(local_var_req).await?;
10741
10742    let local_var_status = local_var_resp.status();
10743    let local_var_content = local_var_resp.text().await?;
10744
10745    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10746        serde_json::from_str(&local_var_content).map_err(Error::from)
10747    } else {
10748        let local_var_entity: Option<UpdateSipCredentialListError> = serde_json::from_str(&local_var_content).ok();
10749        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10750        Err(Error::ResponseError(local_var_error))
10751    }
10752}
10753
10754/// Update the attributes of a domain
10755pub async fn update_sip_domain(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: Option<&str>, voice_fallback_method: Option<&str>, voice_fallback_url: Option<&str>, voice_method: Option<&str>, voice_status_callback_method: Option<&str>, voice_status_callback_url: Option<&str>, voice_url: Option<&str>, sip_registration: Option<bool>, domain_name: Option<&str>, emergency_calling_enabled: Option<bool>, secure: Option<bool>, byoc_trunk_sid: Option<&str>, emergency_caller_sid: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipDomain, Error<UpdateSipDomainError>> {
10756    let local_var_configuration = configuration;
10757
10758    let local_var_client = &local_var_configuration.client;
10759
10760    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/Domains/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10761    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10762
10763    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10764        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10765    }
10766    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10767        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10768    };
10769    let mut local_var_form_params = std::collections::HashMap::new();
10770    if let Some(local_var_param_value) = friendly_name {
10771        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10772    }
10773    if let Some(local_var_param_value) = voice_fallback_method {
10774        local_var_form_params.insert("VoiceFallbackMethod", local_var_param_value.to_string());
10775    }
10776    if let Some(local_var_param_value) = voice_fallback_url {
10777        local_var_form_params.insert("VoiceFallbackUrl", local_var_param_value.to_string());
10778    }
10779    if let Some(local_var_param_value) = voice_method {
10780        local_var_form_params.insert("VoiceMethod", local_var_param_value.to_string());
10781    }
10782    if let Some(local_var_param_value) = voice_status_callback_method {
10783        local_var_form_params.insert("VoiceStatusCallbackMethod", local_var_param_value.to_string());
10784    }
10785    if let Some(local_var_param_value) = voice_status_callback_url {
10786        local_var_form_params.insert("VoiceStatusCallbackUrl", local_var_param_value.to_string());
10787    }
10788    if let Some(local_var_param_value) = voice_url {
10789        local_var_form_params.insert("VoiceUrl", local_var_param_value.to_string());
10790    }
10791    if let Some(local_var_param_value) = sip_registration {
10792        local_var_form_params.insert("SipRegistration", local_var_param_value.to_string());
10793    }
10794    if let Some(local_var_param_value) = domain_name {
10795        local_var_form_params.insert("DomainName", local_var_param_value.to_string());
10796    }
10797    if let Some(local_var_param_value) = emergency_calling_enabled {
10798        local_var_form_params.insert("EmergencyCallingEnabled", local_var_param_value.to_string());
10799    }
10800    if let Some(local_var_param_value) = secure {
10801        local_var_form_params.insert("Secure", local_var_param_value.to_string());
10802    }
10803    if let Some(local_var_param_value) = byoc_trunk_sid {
10804        local_var_form_params.insert("ByocTrunkSid", local_var_param_value.to_string());
10805    }
10806    if let Some(local_var_param_value) = emergency_caller_sid {
10807        local_var_form_params.insert("EmergencyCallerSid", local_var_param_value.to_string());
10808    }
10809    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10810
10811    let local_var_req = local_var_req_builder.build()?;
10812    let local_var_resp = local_var_client.execute(local_var_req).await?;
10813
10814    let local_var_status = local_var_resp.status();
10815    let local_var_content = local_var_resp.text().await?;
10816
10817    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10818        serde_json::from_str(&local_var_content).map_err(Error::from)
10819    } else {
10820        let local_var_entity: Option<UpdateSipDomainError> = serde_json::from_str(&local_var_content).ok();
10821        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10822        Err(Error::ResponseError(local_var_error))
10823    }
10824}
10825
10826/// Rename an IpAccessControlList
10827pub async fn update_sip_ip_access_control_list(configuration: &configuration::Configuration, account_sid: &str, sid: &str, friendly_name: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipIpAccessControlList, Error<UpdateSipIpAccessControlListError>> {
10828    let local_var_configuration = configuration;
10829
10830    let local_var_client = &local_var_configuration.client;
10831
10832    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10833    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10834
10835    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10836        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10837    }
10838    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10839        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10840    };
10841    let mut local_var_form_params = std::collections::HashMap::new();
10842    local_var_form_params.insert("FriendlyName", friendly_name.to_string());
10843    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10844
10845    let local_var_req = local_var_req_builder.build()?;
10846    let local_var_resp = local_var_client.execute(local_var_req).await?;
10847
10848    let local_var_status = local_var_resp.status();
10849    let local_var_content = local_var_resp.text().await?;
10850
10851    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10852        serde_json::from_str(&local_var_content).map_err(Error::from)
10853    } else {
10854        let local_var_entity: Option<UpdateSipIpAccessControlListError> = serde_json::from_str(&local_var_content).ok();
10855        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10856        Err(Error::ResponseError(local_var_error))
10857    }
10858}
10859
10860/// Update an IpAddress resource.
10861pub async fn update_sip_ip_address(configuration: &configuration::Configuration, account_sid: &str, ip_access_control_list_sid: &str, sid: &str, ip_address: Option<&str>, friendly_name: Option<&str>, cidr_prefix_length: Option<i32>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodSipPeriodSipIpAccessControlListPeriodSipIpAddress, Error<UpdateSipIpAddressError>> {
10862    let local_var_configuration = configuration;
10863
10864    let local_var_client = &local_var_configuration.client;
10865
10866    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/SIP/IpAccessControlLists/{IpAccessControlListSid}/IpAddresses/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), IpAccessControlListSid=crate::apis::urlencode(ip_access_control_list_sid), Sid=crate::apis::urlencode(sid));
10867    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10868
10869    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10870        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10871    }
10872    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10873        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10874    };
10875    let mut local_var_form_params = std::collections::HashMap::new();
10876    if let Some(local_var_param_value) = ip_address {
10877        local_var_form_params.insert("IpAddress", local_var_param_value.to_string());
10878    }
10879    if let Some(local_var_param_value) = friendly_name {
10880        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10881    }
10882    if let Some(local_var_param_value) = cidr_prefix_length {
10883        local_var_form_params.insert("CidrPrefixLength", local_var_param_value.to_string());
10884    }
10885    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10886
10887    let local_var_req = local_var_req_builder.build()?;
10888    let local_var_resp = local_var_client.execute(local_var_req).await?;
10889
10890    let local_var_status = local_var_resp.status();
10891    let local_var_content = local_var_resp.text().await?;
10892
10893    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10894        serde_json::from_str(&local_var_content).map_err(Error::from)
10895    } else {
10896        let local_var_entity: Option<UpdateSipIpAddressError> = serde_json::from_str(&local_var_content).ok();
10897        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10898        Err(Error::ResponseError(local_var_error))
10899    }
10900}
10901
10902/// Stop a Siprec using either the SID of the Siprec resource or the `name` used when creating the resource
10903pub async fn update_siprec(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, sid: &str, status: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodSiprec, Error<UpdateSiprecError>> {
10904    let local_var_configuration = configuration;
10905
10906    let local_var_client = &local_var_configuration.client;
10907
10908    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Siprec/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid), Sid=crate::apis::urlencode(sid));
10909    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10910
10911    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10912        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10913    }
10914    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10915        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10916    };
10917    let mut local_var_form_params = std::collections::HashMap::new();
10918    local_var_form_params.insert("Status", status.to_string());
10919    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10920
10921    let local_var_req = local_var_req_builder.build()?;
10922    let local_var_resp = local_var_client.execute(local_var_req).await?;
10923
10924    let local_var_status = local_var_resp.status();
10925    let local_var_content = local_var_resp.text().await?;
10926
10927    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10928        serde_json::from_str(&local_var_content).map_err(Error::from)
10929    } else {
10930        let local_var_entity: Option<UpdateSiprecError> = serde_json::from_str(&local_var_content).ok();
10931        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10932        Err(Error::ResponseError(local_var_error))
10933    }
10934}
10935
10936/// Stop a Stream using either the SID of the Stream resource or the `name` used when creating the resource
10937pub async fn update_stream(configuration: &configuration::Configuration, account_sid: &str, call_sid: &str, sid: &str, status: &str) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodCallPeriodStream, Error<UpdateStreamError>> {
10938    let local_var_configuration = configuration;
10939
10940    let local_var_client = &local_var_configuration.client;
10941
10942    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Calls/{CallSid}/Streams/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), CallSid=crate::apis::urlencode(call_sid), Sid=crate::apis::urlencode(sid));
10943    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10944
10945    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10946        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10947    }
10948    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10949        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10950    };
10951    let mut local_var_form_params = std::collections::HashMap::new();
10952    local_var_form_params.insert("Status", status.to_string());
10953    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10954
10955    let local_var_req = local_var_req_builder.build()?;
10956    let local_var_resp = local_var_client.execute(local_var_req).await?;
10957
10958    let local_var_status = local_var_resp.status();
10959    let local_var_content = local_var_resp.text().await?;
10960
10961    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
10962        serde_json::from_str(&local_var_content).map_err(Error::from)
10963    } else {
10964        let local_var_entity: Option<UpdateStreamError> = serde_json::from_str(&local_var_content).ok();
10965        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
10966        Err(Error::ResponseError(local_var_error))
10967    }
10968}
10969
10970/// Update an instance of a usage trigger
10971pub async fn update_usage_trigger(configuration: &configuration::Configuration, account_sid: &str, sid: &str, callback_method: Option<&str>, callback_url: Option<&str>, friendly_name: Option<&str>) -> Result<crate::models::ApiPeriodV2010PeriodAccountPeriodUsagePeriodUsageTrigger, Error<UpdateUsageTriggerError>> {
10972    let local_var_configuration = configuration;
10973
10974    let local_var_client = &local_var_configuration.client;
10975
10976    let local_var_uri_str = format!("{}/2010-04-01/Accounts/{AccountSid}/Usage/Triggers/{Sid}.json", local_var_configuration.base_path, AccountSid=crate::apis::urlencode(account_sid), Sid=crate::apis::urlencode(sid));
10977    let mut local_var_req_builder = local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());
10978
10979    if let Some(ref local_var_user_agent) = local_var_configuration.user_agent {
10980        local_var_req_builder = local_var_req_builder.header(reqwest::header::USER_AGENT, local_var_user_agent.clone());
10981    }
10982    if let Some(ref local_var_auth_conf) = local_var_configuration.basic_auth {
10983        local_var_req_builder = local_var_req_builder.basic_auth(local_var_auth_conf.0.to_owned(), local_var_auth_conf.1.to_owned());
10984    };
10985    let mut local_var_form_params = std::collections::HashMap::new();
10986    if let Some(local_var_param_value) = callback_method {
10987        local_var_form_params.insert("CallbackMethod", local_var_param_value.to_string());
10988    }
10989    if let Some(local_var_param_value) = callback_url {
10990        local_var_form_params.insert("CallbackUrl", local_var_param_value.to_string());
10991    }
10992    if let Some(local_var_param_value) = friendly_name {
10993        local_var_form_params.insert("FriendlyName", local_var_param_value.to_string());
10994    }
10995    local_var_req_builder = local_var_req_builder.form(&local_var_form_params);
10996
10997    let local_var_req = local_var_req_builder.build()?;
10998    let local_var_resp = local_var_client.execute(local_var_req).await?;
10999
11000    let local_var_status = local_var_resp.status();
11001    let local_var_content = local_var_resp.text().await?;
11002
11003    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
11004        serde_json::from_str(&local_var_content).map_err(Error::from)
11005    } else {
11006        let local_var_entity: Option<UpdateUsageTriggerError> = serde_json::from_str(&local_var_content).ok();
11007        let local_var_error = ResponseContent { status: local_var_status, content: local_var_content, entity: local_var_entity };
11008        Err(Error::ResponseError(local_var_error))
11009    }
11010}
11011
twilio_openapi/apis/default_api.rs

twilio_openapi/apis/
default_api.rs
