1#![allow(non_camel_case_types)]
5#![allow(unused)]
6pub mod model;
7pub mod request;
8use crate::model::*;
9pub struct TwilioClient {
10 pub client: httpclient::Client,
11 authentication: TwilioAuthentication,
12}
13impl TwilioClient {
14 pub fn from_env() -> Self {
15 Self {
16 client: httpclient::Client::new().base_url("https://api.twilio.com"),
17 authentication: TwilioAuthentication::from_env(),
18 }
19 }
20}
21impl TwilioClient {
22 pub fn new(url: &str, authentication: TwilioAuthentication) -> Self {
23 let client = httpclient::Client::new().base_url(url);
24 Self { client, authentication }
25 }
26 pub fn with_authentication(mut self, authentication: TwilioAuthentication) -> Self {
27 self.authentication = authentication;
28 self
29 }
30 pub(crate) fn authenticate<'a>(
31 &self,
32 mut r: httpclient::RequestBuilder<'a>,
33 ) -> httpclient::RequestBuilder<'a> {
34 match &self.authentication {
35 TwilioAuthentication::BasicAuth { basic_auth } => {
36 r = r.basic_auth(basic_auth);
37 }
38 }
39 r
40 }
41 pub fn with_middleware<M: httpclient::Middleware + 'static>(
42 mut self,
43 middleware: M,
44 ) -> Self {
45 self.client = self.client.with_middleware(middleware);
46 self
47 }
48 pub fn list_account(&self) -> request::ListAccountRequest {
50 request::ListAccountRequest {
51 http_client: &self,
52 friendly_name: None,
53 page: None,
54 page_size: None,
55 page_token: None,
56 status: None,
57 }
58 }
59 pub fn create_account(&self) -> request::CreateAccountRequest {
61 request::CreateAccountRequest {
62 http_client: &self,
63 }
64 }
65 pub fn fetch_account(&self, sid: &str) -> request::FetchAccountRequest {
67 request::FetchAccountRequest {
68 http_client: &self,
69 sid: sid.to_owned(),
70 }
71 }
72 pub fn update_account(&self, sid: &str) -> request::UpdateAccountRequest {
74 request::UpdateAccountRequest {
75 http_client: &self,
76 sid: sid.to_owned(),
77 }
78 }
79 pub fn list_address(&self, account_sid: &str) -> request::ListAddressRequest {
80 request::ListAddressRequest {
81 http_client: &self,
82 account_sid: account_sid.to_owned(),
83 customer_name: None,
84 friendly_name: None,
85 iso_country: None,
86 page: None,
87 page_size: None,
88 page_token: None,
89 }
90 }
91 pub fn create_address(&self, account_sid: &str) -> request::CreateAddressRequest {
92 request::CreateAddressRequest {
93 http_client: &self,
94 account_sid: account_sid.to_owned(),
95 }
96 }
97 pub fn fetch_address(
98 &self,
99 account_sid: &str,
100 sid: &str,
101 ) -> request::FetchAddressRequest {
102 request::FetchAddressRequest {
103 http_client: &self,
104 account_sid: account_sid.to_owned(),
105 sid: sid.to_owned(),
106 }
107 }
108 pub fn update_address(
109 &self,
110 account_sid: &str,
111 sid: &str,
112 ) -> request::UpdateAddressRequest {
113 request::UpdateAddressRequest {
114 http_client: &self,
115 account_sid: account_sid.to_owned(),
116 sid: sid.to_owned(),
117 }
118 }
119 pub fn delete_address(
120 &self,
121 account_sid: &str,
122 sid: &str,
123 ) -> request::DeleteAddressRequest {
124 request::DeleteAddressRequest {
125 http_client: &self,
126 account_sid: account_sid.to_owned(),
127 sid: sid.to_owned(),
128 }
129 }
130 pub fn list_application(
132 &self,
133 account_sid: &str,
134 ) -> request::ListApplicationRequest {
135 request::ListApplicationRequest {
136 http_client: &self,
137 account_sid: account_sid.to_owned(),
138 friendly_name: None,
139 page: None,
140 page_size: None,
141 page_token: None,
142 }
143 }
144 pub fn create_application(
146 &self,
147 account_sid: &str,
148 ) -> request::CreateApplicationRequest {
149 request::CreateApplicationRequest {
150 http_client: &self,
151 account_sid: account_sid.to_owned(),
152 }
153 }
154 pub fn fetch_application(
156 &self,
157 account_sid: &str,
158 sid: &str,
159 ) -> request::FetchApplicationRequest {
160 request::FetchApplicationRequest {
161 http_client: &self,
162 account_sid: account_sid.to_owned(),
163 sid: sid.to_owned(),
164 }
165 }
166 pub fn update_application(
168 &self,
169 account_sid: &str,
170 sid: &str,
171 ) -> request::UpdateApplicationRequest {
172 request::UpdateApplicationRequest {
173 http_client: &self,
174 account_sid: account_sid.to_owned(),
175 sid: sid.to_owned(),
176 }
177 }
178 pub fn delete_application(
180 &self,
181 account_sid: &str,
182 sid: &str,
183 ) -> request::DeleteApplicationRequest {
184 request::DeleteApplicationRequest {
185 http_client: &self,
186 account_sid: account_sid.to_owned(),
187 sid: sid.to_owned(),
188 }
189 }
190 pub fn fetch_authorized_connect_app(
192 &self,
193 account_sid: &str,
194 connect_app_sid: &str,
195 ) -> request::FetchAuthorizedConnectAppRequest {
196 request::FetchAuthorizedConnectAppRequest {
197 http_client: &self,
198 account_sid: account_sid.to_owned(),
199 connect_app_sid: connect_app_sid.to_owned(),
200 }
201 }
202 pub fn list_authorized_connect_app(
204 &self,
205 account_sid: &str,
206 ) -> request::ListAuthorizedConnectAppRequest {
207 request::ListAuthorizedConnectAppRequest {
208 http_client: &self,
209 account_sid: account_sid.to_owned(),
210 page: None,
211 page_size: None,
212 page_token: None,
213 }
214 }
215 pub fn list_available_phone_number_country(
216 &self,
217 account_sid: &str,
218 ) -> request::ListAvailablePhoneNumberCountryRequest {
219 request::ListAvailablePhoneNumberCountryRequest {
220 http_client: &self,
221 account_sid: account_sid.to_owned(),
222 page: None,
223 page_size: None,
224 page_token: None,
225 }
226 }
227 pub fn fetch_available_phone_number_country(
228 &self,
229 account_sid: &str,
230 country_code: &str,
231 ) -> request::FetchAvailablePhoneNumberCountryRequest {
232 request::FetchAvailablePhoneNumberCountryRequest {
233 http_client: &self,
234 account_sid: account_sid.to_owned(),
235 country_code: country_code.to_owned(),
236 }
237 }
238 pub fn list_available_phone_number_local(
239 &self,
240 account_sid: &str,
241 country_code: &str,
242 ) -> request::ListAvailablePhoneNumberLocalRequest {
243 request::ListAvailablePhoneNumberLocalRequest {
244 http_client: &self,
245 account_sid: account_sid.to_owned(),
246 area_code: None,
247 beta: None,
248 contains: None,
249 country_code: country_code.to_owned(),
250 distance: None,
251 exclude_all_address_required: None,
252 exclude_foreign_address_required: None,
253 exclude_local_address_required: None,
254 fax_enabled: None,
255 in_lata: None,
256 in_locality: None,
257 in_postal_code: None,
258 in_rate_center: None,
259 in_region: None,
260 mms_enabled: None,
261 near_lat_long: None,
262 near_number: None,
263 page: None,
264 page_size: None,
265 page_token: None,
266 sms_enabled: None,
267 voice_enabled: None,
268 }
269 }
270 pub fn list_available_phone_number_machine_to_machine(
271 &self,
272 account_sid: &str,
273 country_code: &str,
274 ) -> request::ListAvailablePhoneNumberMachineToMachineRequest {
275 request::ListAvailablePhoneNumberMachineToMachineRequest {
276 http_client: &self,
277 account_sid: account_sid.to_owned(),
278 area_code: None,
279 beta: None,
280 contains: None,
281 country_code: country_code.to_owned(),
282 distance: None,
283 exclude_all_address_required: None,
284 exclude_foreign_address_required: None,
285 exclude_local_address_required: None,
286 fax_enabled: None,
287 in_lata: None,
288 in_locality: None,
289 in_postal_code: None,
290 in_rate_center: None,
291 in_region: None,
292 mms_enabled: None,
293 near_lat_long: None,
294 near_number: None,
295 page: None,
296 page_size: None,
297 page_token: None,
298 sms_enabled: None,
299 voice_enabled: None,
300 }
301 }
302 pub fn list_available_phone_number_mobile(
303 &self,
304 account_sid: &str,
305 country_code: &str,
306 ) -> request::ListAvailablePhoneNumberMobileRequest {
307 request::ListAvailablePhoneNumberMobileRequest {
308 http_client: &self,
309 account_sid: account_sid.to_owned(),
310 area_code: None,
311 beta: None,
312 contains: None,
313 country_code: country_code.to_owned(),
314 distance: None,
315 exclude_all_address_required: None,
316 exclude_foreign_address_required: None,
317 exclude_local_address_required: None,
318 fax_enabled: None,
319 in_lata: None,
320 in_locality: None,
321 in_postal_code: None,
322 in_rate_center: None,
323 in_region: None,
324 mms_enabled: None,
325 near_lat_long: None,
326 near_number: None,
327 page: None,
328 page_size: None,
329 page_token: None,
330 sms_enabled: None,
331 voice_enabled: None,
332 }
333 }
334 pub fn list_available_phone_number_national(
335 &self,
336 account_sid: &str,
337 country_code: &str,
338 ) -> request::ListAvailablePhoneNumberNationalRequest {
339 request::ListAvailablePhoneNumberNationalRequest {
340 http_client: &self,
341 account_sid: account_sid.to_owned(),
342 area_code: None,
343 beta: None,
344 contains: None,
345 country_code: country_code.to_owned(),
346 distance: None,
347 exclude_all_address_required: None,
348 exclude_foreign_address_required: None,
349 exclude_local_address_required: None,
350 fax_enabled: None,
351 in_lata: None,
352 in_locality: None,
353 in_postal_code: None,
354 in_rate_center: None,
355 in_region: None,
356 mms_enabled: None,
357 near_lat_long: None,
358 near_number: None,
359 page: None,
360 page_size: None,
361 page_token: None,
362 sms_enabled: None,
363 voice_enabled: None,
364 }
365 }
366 pub fn list_available_phone_number_shared_cost(
367 &self,
368 account_sid: &str,
369 country_code: &str,
370 ) -> request::ListAvailablePhoneNumberSharedCostRequest {
371 request::ListAvailablePhoneNumberSharedCostRequest {
372 http_client: &self,
373 account_sid: account_sid.to_owned(),
374 area_code: None,
375 beta: None,
376 contains: None,
377 country_code: country_code.to_owned(),
378 distance: None,
379 exclude_all_address_required: None,
380 exclude_foreign_address_required: None,
381 exclude_local_address_required: None,
382 fax_enabled: None,
383 in_lata: None,
384 in_locality: None,
385 in_postal_code: None,
386 in_rate_center: None,
387 in_region: None,
388 mms_enabled: None,
389 near_lat_long: None,
390 near_number: None,
391 page: None,
392 page_size: None,
393 page_token: None,
394 sms_enabled: None,
395 voice_enabled: None,
396 }
397 }
398 pub fn list_available_phone_number_toll_free(
399 &self,
400 account_sid: &str,
401 country_code: &str,
402 ) -> request::ListAvailablePhoneNumberTollFreeRequest {
403 request::ListAvailablePhoneNumberTollFreeRequest {
404 http_client: &self,
405 account_sid: account_sid.to_owned(),
406 area_code: None,
407 beta: None,
408 contains: None,
409 country_code: country_code.to_owned(),
410 distance: None,
411 exclude_all_address_required: None,
412 exclude_foreign_address_required: None,
413 exclude_local_address_required: None,
414 fax_enabled: None,
415 in_lata: None,
416 in_locality: None,
417 in_postal_code: None,
418 in_rate_center: None,
419 in_region: None,
420 mms_enabled: None,
421 near_lat_long: None,
422 near_number: None,
423 page: None,
424 page_size: None,
425 page_token: None,
426 sms_enabled: None,
427 voice_enabled: None,
428 }
429 }
430 pub fn list_available_phone_number_voip(
431 &self,
432 account_sid: &str,
433 country_code: &str,
434 ) -> request::ListAvailablePhoneNumberVoipRequest {
435 request::ListAvailablePhoneNumberVoipRequest {
436 http_client: &self,
437 account_sid: account_sid.to_owned(),
438 area_code: None,
439 beta: None,
440 contains: None,
441 country_code: country_code.to_owned(),
442 distance: None,
443 exclude_all_address_required: None,
444 exclude_foreign_address_required: None,
445 exclude_local_address_required: None,
446 fax_enabled: None,
447 in_lata: None,
448 in_locality: None,
449 in_postal_code: None,
450 in_rate_center: None,
451 in_region: None,
452 mms_enabled: None,
453 near_lat_long: None,
454 near_number: None,
455 page: None,
456 page_size: None,
457 page_token: None,
458 sms_enabled: None,
459 voice_enabled: None,
460 }
461 }
462 pub fn fetch_balance(&self, account_sid: &str) -> request::FetchBalanceRequest {
464 request::FetchBalanceRequest {
465 http_client: &self,
466 account_sid: account_sid.to_owned(),
467 }
468 }
469 pub fn list_call(&self, account_sid: &str) -> request::ListCallRequest {
471 request::ListCallRequest {
472 http_client: &self,
473 account_sid: account_sid.to_owned(),
474 end_time: None,
475 end_time_gt: None,
476 end_time_lt: None,
477 from: None,
478 page: None,
479 page_size: None,
480 page_token: None,
481 parent_call_sid: None,
482 start_time: None,
483 start_time_gt: None,
484 start_time_lt: None,
485 status: None,
486 to: None,
487 }
488 }
489 pub fn create_call(&self, account_sid: &str) -> request::CreateCallRequest {
491 request::CreateCallRequest {
492 http_client: &self,
493 account_sid: account_sid.to_owned(),
494 }
495 }
496 pub fn fetch_call(&self, account_sid: &str, sid: &str) -> request::FetchCallRequest {
498 request::FetchCallRequest {
499 http_client: &self,
500 account_sid: account_sid.to_owned(),
501 sid: sid.to_owned(),
502 }
503 }
504 pub fn update_call(
506 &self,
507 account_sid: &str,
508 sid: &str,
509 ) -> request::UpdateCallRequest {
510 request::UpdateCallRequest {
511 http_client: &self,
512 account_sid: account_sid.to_owned(),
513 sid: sid.to_owned(),
514 }
515 }
516 pub fn delete_call(
518 &self,
519 account_sid: &str,
520 sid: &str,
521 ) -> request::DeleteCallRequest {
522 request::DeleteCallRequest {
523 http_client: &self,
524 account_sid: account_sid.to_owned(),
525 sid: sid.to_owned(),
526 }
527 }
528 pub fn list_call_event(
530 &self,
531 account_sid: &str,
532 call_sid: &str,
533 ) -> request::ListCallEventRequest {
534 request::ListCallEventRequest {
535 http_client: &self,
536 account_sid: account_sid.to_owned(),
537 call_sid: call_sid.to_owned(),
538 page: None,
539 page_size: None,
540 page_token: None,
541 }
542 }
543 pub fn fetch_call_feedback(
545 &self,
546 account_sid: &str,
547 call_sid: &str,
548 ) -> request::FetchCallFeedbackRequest {
549 request::FetchCallFeedbackRequest {
550 http_client: &self,
551 account_sid: account_sid.to_owned(),
552 call_sid: call_sid.to_owned(),
553 }
554 }
555 pub fn update_call_feedback(
557 &self,
558 account_sid: &str,
559 call_sid: &str,
560 ) -> request::UpdateCallFeedbackRequest {
561 request::UpdateCallFeedbackRequest {
562 http_client: &self,
563 account_sid: account_sid.to_owned(),
564 call_sid: call_sid.to_owned(),
565 }
566 }
567 pub fn create_call_feedback_summary(
569 &self,
570 account_sid: &str,
571 ) -> request::CreateCallFeedbackSummaryRequest {
572 request::CreateCallFeedbackSummaryRequest {
573 http_client: &self,
574 account_sid: account_sid.to_owned(),
575 }
576 }
577 pub fn fetch_call_feedback_summary(
579 &self,
580 account_sid: &str,
581 sid: &str,
582 ) -> request::FetchCallFeedbackSummaryRequest {
583 request::FetchCallFeedbackSummaryRequest {
584 http_client: &self,
585 account_sid: account_sid.to_owned(),
586 sid: sid.to_owned(),
587 }
588 }
589 pub fn delete_call_feedback_summary(
591 &self,
592 account_sid: &str,
593 sid: &str,
594 ) -> request::DeleteCallFeedbackSummaryRequest {
595 request::DeleteCallFeedbackSummaryRequest {
596 http_client: &self,
597 account_sid: account_sid.to_owned(),
598 sid: sid.to_owned(),
599 }
600 }
601 pub fn fetch_call_notification(
602 &self,
603 account_sid: &str,
604 call_sid: &str,
605 sid: &str,
606 ) -> request::FetchCallNotificationRequest {
607 request::FetchCallNotificationRequest {
608 http_client: &self,
609 account_sid: account_sid.to_owned(),
610 call_sid: call_sid.to_owned(),
611 sid: sid.to_owned(),
612 }
613 }
614 pub fn list_call_notification(
615 &self,
616 account_sid: &str,
617 call_sid: &str,
618 ) -> request::ListCallNotificationRequest {
619 request::ListCallNotificationRequest {
620 http_client: &self,
621 account_sid: account_sid.to_owned(),
622 call_sid: call_sid.to_owned(),
623 log: None,
624 message_date: None,
625 message_date_gt: None,
626 message_date_lt: None,
627 page: None,
628 page_size: None,
629 page_token: None,
630 }
631 }
632 pub fn list_call_recording(
634 &self,
635 account_sid: &str,
636 call_sid: &str,
637 ) -> request::ListCallRecordingRequest {
638 request::ListCallRecordingRequest {
639 http_client: &self,
640 account_sid: account_sid.to_owned(),
641 call_sid: call_sid.to_owned(),
642 date_created: None,
643 date_created_gt: None,
644 date_created_lt: None,
645 page: None,
646 page_size: None,
647 page_token: None,
648 }
649 }
650 pub fn create_call_recording(
652 &self,
653 account_sid: &str,
654 call_sid: &str,
655 ) -> request::CreateCallRecordingRequest {
656 request::CreateCallRecordingRequest {
657 http_client: &self,
658 account_sid: account_sid.to_owned(),
659 call_sid: call_sid.to_owned(),
660 }
661 }
662 pub fn fetch_call_recording(
664 &self,
665 account_sid: &str,
666 call_sid: &str,
667 sid: &str,
668 ) -> request::FetchCallRecordingRequest {
669 request::FetchCallRecordingRequest {
670 http_client: &self,
671 account_sid: account_sid.to_owned(),
672 call_sid: call_sid.to_owned(),
673 sid: sid.to_owned(),
674 }
675 }
676 pub fn update_call_recording(
678 &self,
679 account_sid: &str,
680 call_sid: &str,
681 sid: &str,
682 ) -> request::UpdateCallRecordingRequest {
683 request::UpdateCallRecordingRequest {
684 http_client: &self,
685 account_sid: account_sid.to_owned(),
686 call_sid: call_sid.to_owned(),
687 sid: sid.to_owned(),
688 }
689 }
690 pub fn delete_call_recording(
692 &self,
693 account_sid: &str,
694 call_sid: &str,
695 sid: &str,
696 ) -> request::DeleteCallRecordingRequest {
697 request::DeleteCallRecordingRequest {
698 http_client: &self,
699 account_sid: account_sid.to_owned(),
700 call_sid: call_sid.to_owned(),
701 sid: sid.to_owned(),
702 }
703 }
704 pub fn fetch_conference(
706 &self,
707 account_sid: &str,
708 sid: &str,
709 ) -> request::FetchConferenceRequest {
710 request::FetchConferenceRequest {
711 http_client: &self,
712 account_sid: account_sid.to_owned(),
713 sid: sid.to_owned(),
714 }
715 }
716 pub fn update_conference(
717 &self,
718 account_sid: &str,
719 sid: &str,
720 ) -> request::UpdateConferenceRequest {
721 request::UpdateConferenceRequest {
722 http_client: &self,
723 account_sid: account_sid.to_owned(),
724 sid: sid.to_owned(),
725 }
726 }
727 pub fn list_conference(&self, account_sid: &str) -> request::ListConferenceRequest {
729 request::ListConferenceRequest {
730 http_client: &self,
731 account_sid: account_sid.to_owned(),
732 date_created: None,
733 date_created_gt: None,
734 date_created_lt: None,
735 date_updated: None,
736 date_updated_gt: None,
737 date_updated_lt: None,
738 friendly_name: None,
739 page: None,
740 page_size: None,
741 page_token: None,
742 status: None,
743 }
744 }
745 pub fn fetch_conference_recording(
747 &self,
748 account_sid: &str,
749 conference_sid: &str,
750 sid: &str,
751 ) -> request::FetchConferenceRecordingRequest {
752 request::FetchConferenceRecordingRequest {
753 http_client: &self,
754 account_sid: account_sid.to_owned(),
755 conference_sid: conference_sid.to_owned(),
756 sid: sid.to_owned(),
757 }
758 }
759 pub fn update_conference_recording(
761 &self,
762 account_sid: &str,
763 conference_sid: &str,
764 sid: &str,
765 ) -> request::UpdateConferenceRecordingRequest {
766 request::UpdateConferenceRecordingRequest {
767 http_client: &self,
768 account_sid: account_sid.to_owned(),
769 conference_sid: conference_sid.to_owned(),
770 sid: sid.to_owned(),
771 }
772 }
773 pub fn delete_conference_recording(
775 &self,
776 account_sid: &str,
777 conference_sid: &str,
778 sid: &str,
779 ) -> request::DeleteConferenceRecordingRequest {
780 request::DeleteConferenceRecordingRequest {
781 http_client: &self,
782 account_sid: account_sid.to_owned(),
783 conference_sid: conference_sid.to_owned(),
784 sid: sid.to_owned(),
785 }
786 }
787 pub fn list_conference_recording(
789 &self,
790 account_sid: &str,
791 conference_sid: &str,
792 ) -> request::ListConferenceRecordingRequest {
793 request::ListConferenceRecordingRequest {
794 http_client: &self,
795 account_sid: account_sid.to_owned(),
796 conference_sid: conference_sid.to_owned(),
797 date_created: None,
798 date_created_gt: None,
799 date_created_lt: None,
800 page: None,
801 page_size: None,
802 page_token: None,
803 }
804 }
805 pub fn fetch_connect_app(
807 &self,
808 account_sid: &str,
809 sid: &str,
810 ) -> request::FetchConnectAppRequest {
811 request::FetchConnectAppRequest {
812 http_client: &self,
813 account_sid: account_sid.to_owned(),
814 sid: sid.to_owned(),
815 }
816 }
817 pub fn update_connect_app(
819 &self,
820 account_sid: &str,
821 sid: &str,
822 ) -> request::UpdateConnectAppRequest {
823 request::UpdateConnectAppRequest {
824 http_client: &self,
825 account_sid: account_sid.to_owned(),
826 sid: sid.to_owned(),
827 }
828 }
829 pub fn delete_connect_app(
831 &self,
832 account_sid: &str,
833 sid: &str,
834 ) -> request::DeleteConnectAppRequest {
835 request::DeleteConnectAppRequest {
836 http_client: &self,
837 account_sid: account_sid.to_owned(),
838 sid: sid.to_owned(),
839 }
840 }
841 pub fn list_connect_app(&self, account_sid: &str) -> request::ListConnectAppRequest {
843 request::ListConnectAppRequest {
844 http_client: &self,
845 account_sid: account_sid.to_owned(),
846 page: None,
847 page_size: None,
848 page_token: None,
849 }
850 }
851 pub fn list_dependent_phone_number(
852 &self,
853 account_sid: &str,
854 address_sid: &str,
855 ) -> request::ListDependentPhoneNumberRequest {
856 request::ListDependentPhoneNumberRequest {
857 http_client: &self,
858 account_sid: account_sid.to_owned(),
859 address_sid: address_sid.to_owned(),
860 page: None,
861 page_size: None,
862 page_token: None,
863 }
864 }
865 pub fn fetch_incoming_phone_number(
867 &self,
868 account_sid: &str,
869 sid: &str,
870 ) -> request::FetchIncomingPhoneNumberRequest {
871 request::FetchIncomingPhoneNumberRequest {
872 http_client: &self,
873 account_sid: account_sid.to_owned(),
874 sid: sid.to_owned(),
875 }
876 }
877 pub fn update_incoming_phone_number(
879 &self,
880 account_sid: &str,
881 sid: &str,
882 ) -> request::UpdateIncomingPhoneNumberRequest {
883 request::UpdateIncomingPhoneNumberRequest {
884 http_client: &self,
885 account_sid: account_sid.to_owned(),
886 sid: sid.to_owned(),
887 }
888 }
889 pub fn delete_incoming_phone_number(
891 &self,
892 account_sid: &str,
893 sid: &str,
894 ) -> request::DeleteIncomingPhoneNumberRequest {
895 request::DeleteIncomingPhoneNumberRequest {
896 http_client: &self,
897 account_sid: account_sid.to_owned(),
898 sid: sid.to_owned(),
899 }
900 }
901 pub fn list_incoming_phone_number(
903 &self,
904 account_sid: &str,
905 ) -> request::ListIncomingPhoneNumberRequest {
906 request::ListIncomingPhoneNumberRequest {
907 http_client: &self,
908 account_sid: account_sid.to_owned(),
909 beta: None,
910 friendly_name: None,
911 origin: None,
912 page: None,
913 page_size: None,
914 page_token: None,
915 phone_number: None,
916 }
917 }
918 pub fn create_incoming_phone_number(
920 &self,
921 account_sid: &str,
922 ) -> request::CreateIncomingPhoneNumberRequest {
923 request::CreateIncomingPhoneNumberRequest {
924 http_client: &self,
925 account_sid: account_sid.to_owned(),
926 }
927 }
928 pub fn fetch_incoming_phone_number_assigned_add_on(
930 &self,
931 account_sid: &str,
932 resource_sid: &str,
933 sid: &str,
934 ) -> request::FetchIncomingPhoneNumberAssignedAddOnRequest {
935 request::FetchIncomingPhoneNumberAssignedAddOnRequest {
936 http_client: &self,
937 account_sid: account_sid.to_owned(),
938 resource_sid: resource_sid.to_owned(),
939 sid: sid.to_owned(),
940 }
941 }
942 pub fn delete_incoming_phone_number_assigned_add_on(
944 &self,
945 account_sid: &str,
946 resource_sid: &str,
947 sid: &str,
948 ) -> request::DeleteIncomingPhoneNumberAssignedAddOnRequest {
949 request::DeleteIncomingPhoneNumberAssignedAddOnRequest {
950 http_client: &self,
951 account_sid: account_sid.to_owned(),
952 resource_sid: resource_sid.to_owned(),
953 sid: sid.to_owned(),
954 }
955 }
956 pub fn list_incoming_phone_number_assigned_add_on(
958 &self,
959 account_sid: &str,
960 resource_sid: &str,
961 ) -> request::ListIncomingPhoneNumberAssignedAddOnRequest {
962 request::ListIncomingPhoneNumberAssignedAddOnRequest {
963 http_client: &self,
964 account_sid: account_sid.to_owned(),
965 page: None,
966 page_size: None,
967 page_token: None,
968 resource_sid: resource_sid.to_owned(),
969 }
970 }
971 pub fn create_incoming_phone_number_assigned_add_on(
973 &self,
974 account_sid: &str,
975 resource_sid: &str,
976 ) -> request::CreateIncomingPhoneNumberAssignedAddOnRequest {
977 request::CreateIncomingPhoneNumberAssignedAddOnRequest {
978 http_client: &self,
979 account_sid: account_sid.to_owned(),
980 resource_sid: resource_sid.to_owned(),
981 }
982 }
983 pub fn fetch_incoming_phone_number_assigned_add_on_extension(
985 &self,
986 args: request::FetchIncomingPhoneNumberAssignedAddOnExtensionRequired,
987 ) -> request::FetchIncomingPhoneNumberAssignedAddOnExtensionRequest {
988 request::FetchIncomingPhoneNumberAssignedAddOnExtensionRequest {
989 http_client: &self,
990 account_sid: args.account_sid.to_owned(),
991 assigned_add_on_sid: args.assigned_add_on_sid.to_owned(),
992 resource_sid: args.resource_sid.to_owned(),
993 sid: args.sid.to_owned(),
994 }
995 }
996 pub fn list_incoming_phone_number_assigned_add_on_extension(
998 &self,
999 account_sid: &str,
1000 assigned_add_on_sid: &str,
1001 resource_sid: &str,
1002 ) -> request::ListIncomingPhoneNumberAssignedAddOnExtensionRequest {
1003 request::ListIncomingPhoneNumberAssignedAddOnExtensionRequest {
1004 http_client: &self,
1005 account_sid: account_sid.to_owned(),
1006 assigned_add_on_sid: assigned_add_on_sid.to_owned(),
1007 page: None,
1008 page_size: None,
1009 page_token: None,
1010 resource_sid: resource_sid.to_owned(),
1011 }
1012 }
1013 pub fn list_incoming_phone_number_local(
1014 &self,
1015 account_sid: &str,
1016 ) -> request::ListIncomingPhoneNumberLocalRequest {
1017 request::ListIncomingPhoneNumberLocalRequest {
1018 http_client: &self,
1019 account_sid: account_sid.to_owned(),
1020 beta: None,
1021 friendly_name: None,
1022 origin: None,
1023 page: None,
1024 page_size: None,
1025 page_token: None,
1026 phone_number: None,
1027 }
1028 }
1029 pub fn create_incoming_phone_number_local(
1030 &self,
1031 account_sid: &str,
1032 ) -> request::CreateIncomingPhoneNumberLocalRequest {
1033 request::CreateIncomingPhoneNumberLocalRequest {
1034 http_client: &self,
1035 account_sid: account_sid.to_owned(),
1036 }
1037 }
1038 pub fn list_incoming_phone_number_mobile(
1039 &self,
1040 account_sid: &str,
1041 ) -> request::ListIncomingPhoneNumberMobileRequest {
1042 request::ListIncomingPhoneNumberMobileRequest {
1043 http_client: &self,
1044 account_sid: account_sid.to_owned(),
1045 beta: None,
1046 friendly_name: None,
1047 origin: None,
1048 page: None,
1049 page_size: None,
1050 page_token: None,
1051 phone_number: None,
1052 }
1053 }
1054 pub fn create_incoming_phone_number_mobile(
1055 &self,
1056 account_sid: &str,
1057 ) -> request::CreateIncomingPhoneNumberMobileRequest {
1058 request::CreateIncomingPhoneNumberMobileRequest {
1059 http_client: &self,
1060 account_sid: account_sid.to_owned(),
1061 }
1062 }
1063 pub fn list_incoming_phone_number_toll_free(
1064 &self,
1065 account_sid: &str,
1066 ) -> request::ListIncomingPhoneNumberTollFreeRequest {
1067 request::ListIncomingPhoneNumberTollFreeRequest {
1068 http_client: &self,
1069 account_sid: account_sid.to_owned(),
1070 beta: None,
1071 friendly_name: None,
1072 origin: None,
1073 page: None,
1074 page_size: None,
1075 page_token: None,
1076 phone_number: None,
1077 }
1078 }
1079 pub fn create_incoming_phone_number_toll_free(
1080 &self,
1081 account_sid: &str,
1082 ) -> request::CreateIncomingPhoneNumberTollFreeRequest {
1083 request::CreateIncomingPhoneNumberTollFreeRequest {
1084 http_client: &self,
1085 account_sid: account_sid.to_owned(),
1086 }
1087 }
1088 pub fn fetch_key(&self, account_sid: &str, sid: &str) -> request::FetchKeyRequest {
1089 request::FetchKeyRequest {
1090 http_client: &self,
1091 account_sid: account_sid.to_owned(),
1092 sid: sid.to_owned(),
1093 }
1094 }
1095 pub fn update_key(&self, account_sid: &str, sid: &str) -> request::UpdateKeyRequest {
1096 request::UpdateKeyRequest {
1097 http_client: &self,
1098 account_sid: account_sid.to_owned(),
1099 sid: sid.to_owned(),
1100 }
1101 }
1102 pub fn delete_key(&self, account_sid: &str, sid: &str) -> request::DeleteKeyRequest {
1103 request::DeleteKeyRequest {
1104 http_client: &self,
1105 account_sid: account_sid.to_owned(),
1106 sid: sid.to_owned(),
1107 }
1108 }
1109 pub fn list_key(&self, account_sid: &str) -> request::ListKeyRequest {
1110 request::ListKeyRequest {
1111 http_client: &self,
1112 account_sid: account_sid.to_owned(),
1113 page: None,
1114 page_size: None,
1115 page_token: None,
1116 }
1117 }
1118 pub fn create_new_key(&self, account_sid: &str) -> request::CreateNewKeyRequest {
1119 request::CreateNewKeyRequest {
1120 http_client: &self,
1121 account_sid: account_sid.to_owned(),
1122 }
1123 }
1124 pub fn fetch_media(
1126 &self,
1127 account_sid: &str,
1128 message_sid: &str,
1129 sid: &str,
1130 ) -> request::FetchMediaRequest {
1131 request::FetchMediaRequest {
1132 http_client: &self,
1133 account_sid: account_sid.to_owned(),
1134 message_sid: message_sid.to_owned(),
1135 sid: sid.to_owned(),
1136 }
1137 }
1138 pub fn delete_media(
1140 &self,
1141 account_sid: &str,
1142 message_sid: &str,
1143 sid: &str,
1144 ) -> request::DeleteMediaRequest {
1145 request::DeleteMediaRequest {
1146 http_client: &self,
1147 account_sid: account_sid.to_owned(),
1148 message_sid: message_sid.to_owned(),
1149 sid: sid.to_owned(),
1150 }
1151 }
1152 pub fn list_media(
1154 &self,
1155 account_sid: &str,
1156 message_sid: &str,
1157 ) -> request::ListMediaRequest {
1158 request::ListMediaRequest {
1159 http_client: &self,
1160 account_sid: account_sid.to_owned(),
1161 date_created: None,
1162 date_created_gt: None,
1163 date_created_lt: None,
1164 message_sid: message_sid.to_owned(),
1165 page: None,
1166 page_size: None,
1167 page_token: None,
1168 }
1169 }
1170 pub fn fetch_member(
1172 &self,
1173 account_sid: &str,
1174 call_sid: &str,
1175 queue_sid: &str,
1176 ) -> request::FetchMemberRequest {
1177 request::FetchMemberRequest {
1178 http_client: &self,
1179 account_sid: account_sid.to_owned(),
1180 call_sid: call_sid.to_owned(),
1181 queue_sid: queue_sid.to_owned(),
1182 }
1183 }
1184 pub fn update_member(
1186 &self,
1187 account_sid: &str,
1188 call_sid: &str,
1189 queue_sid: &str,
1190 ) -> request::UpdateMemberRequest {
1191 request::UpdateMemberRequest {
1192 http_client: &self,
1193 account_sid: account_sid.to_owned(),
1194 call_sid: call_sid.to_owned(),
1195 queue_sid: queue_sid.to_owned(),
1196 }
1197 }
1198 pub fn list_member(
1200 &self,
1201 account_sid: &str,
1202 queue_sid: &str,
1203 ) -> request::ListMemberRequest {
1204 request::ListMemberRequest {
1205 http_client: &self,
1206 account_sid: account_sid.to_owned(),
1207 page: None,
1208 page_size: None,
1209 page_token: None,
1210 queue_sid: queue_sid.to_owned(),
1211 }
1212 }
1213 pub fn list_message(&self, account_sid: &str) -> request::ListMessageRequest {
1215 request::ListMessageRequest {
1216 http_client: &self,
1217 account_sid: account_sid.to_owned(),
1218 date_sent: None,
1219 date_sent_gt: None,
1220 date_sent_lt: None,
1221 from: None,
1222 page: None,
1223 page_size: None,
1224 page_token: None,
1225 to: None,
1226 }
1227 }
1228 pub fn create_message(&self, account_sid: &str) -> request::CreateMessageRequest {
1230 request::CreateMessageRequest {
1231 http_client: &self,
1232 account_sid: account_sid.to_owned(),
1233 }
1234 }
1235 pub fn fetch_message(
1237 &self,
1238 account_sid: &str,
1239 sid: &str,
1240 ) -> request::FetchMessageRequest {
1241 request::FetchMessageRequest {
1242 http_client: &self,
1243 account_sid: account_sid.to_owned(),
1244 sid: sid.to_owned(),
1245 }
1246 }
1247 pub fn update_message(
1249 &self,
1250 account_sid: &str,
1251 sid: &str,
1252 ) -> request::UpdateMessageRequest {
1253 request::UpdateMessageRequest {
1254 http_client: &self,
1255 account_sid: account_sid.to_owned(),
1256 sid: sid.to_owned(),
1257 }
1258 }
1259 pub fn delete_message(
1261 &self,
1262 account_sid: &str,
1263 sid: &str,
1264 ) -> request::DeleteMessageRequest {
1265 request::DeleteMessageRequest {
1266 http_client: &self,
1267 account_sid: account_sid.to_owned(),
1268 sid: sid.to_owned(),
1269 }
1270 }
1271 pub fn create_message_feedback(
1272 &self,
1273 account_sid: &str,
1274 message_sid: &str,
1275 ) -> request::CreateMessageFeedbackRequest {
1276 request::CreateMessageFeedbackRequest {
1277 http_client: &self,
1278 account_sid: account_sid.to_owned(),
1279 message_sid: message_sid.to_owned(),
1280 }
1281 }
1282 pub fn list_signing_key(&self, account_sid: &str) -> request::ListSigningKeyRequest {
1283 request::ListSigningKeyRequest {
1284 http_client: &self,
1285 account_sid: account_sid.to_owned(),
1286 page: None,
1287 page_size: None,
1288 page_token: None,
1289 }
1290 }
1291 pub fn create_new_signing_key(
1293 &self,
1294 account_sid: &str,
1295 ) -> request::CreateNewSigningKeyRequest {
1296 request::CreateNewSigningKeyRequest {
1297 http_client: &self,
1298 account_sid: account_sid.to_owned(),
1299 }
1300 }
1301 pub fn fetch_notification(
1303 &self,
1304 account_sid: &str,
1305 sid: &str,
1306 ) -> request::FetchNotificationRequest {
1307 request::FetchNotificationRequest {
1308 http_client: &self,
1309 account_sid: account_sid.to_owned(),
1310 sid: sid.to_owned(),
1311 }
1312 }
1313 pub fn list_notification(
1315 &self,
1316 account_sid: &str,
1317 ) -> request::ListNotificationRequest {
1318 request::ListNotificationRequest {
1319 http_client: &self,
1320 account_sid: account_sid.to_owned(),
1321 log: None,
1322 message_date: None,
1323 message_date_gt: None,
1324 message_date_lt: None,
1325 page: None,
1326 page_size: None,
1327 page_token: None,
1328 }
1329 }
1330 pub fn fetch_outgoing_caller_id(
1332 &self,
1333 account_sid: &str,
1334 sid: &str,
1335 ) -> request::FetchOutgoingCallerIdRequest {
1336 request::FetchOutgoingCallerIdRequest {
1337 http_client: &self,
1338 account_sid: account_sid.to_owned(),
1339 sid: sid.to_owned(),
1340 }
1341 }
1342 pub fn update_outgoing_caller_id(
1344 &self,
1345 account_sid: &str,
1346 sid: &str,
1347 ) -> request::UpdateOutgoingCallerIdRequest {
1348 request::UpdateOutgoingCallerIdRequest {
1349 http_client: &self,
1350 account_sid: account_sid.to_owned(),
1351 sid: sid.to_owned(),
1352 }
1353 }
1354 pub fn delete_outgoing_caller_id(
1356 &self,
1357 account_sid: &str,
1358 sid: &str,
1359 ) -> request::DeleteOutgoingCallerIdRequest {
1360 request::DeleteOutgoingCallerIdRequest {
1361 http_client: &self,
1362 account_sid: account_sid.to_owned(),
1363 sid: sid.to_owned(),
1364 }
1365 }
1366 pub fn list_outgoing_caller_id(
1368 &self,
1369 account_sid: &str,
1370 ) -> request::ListOutgoingCallerIdRequest {
1371 request::ListOutgoingCallerIdRequest {
1372 http_client: &self,
1373 account_sid: account_sid.to_owned(),
1374 friendly_name: None,
1375 page: None,
1376 page_size: None,
1377 page_token: None,
1378 phone_number: None,
1379 }
1380 }
1381 pub fn create_validation_request(
1382 &self,
1383 account_sid: &str,
1384 ) -> request::CreateValidationRequestRequest {
1385 request::CreateValidationRequestRequest {
1386 http_client: &self,
1387 account_sid: account_sid.to_owned(),
1388 }
1389 }
1390 pub fn fetch_participant(
1392 &self,
1393 account_sid: &str,
1394 call_sid: &str,
1395 conference_sid: &str,
1396 ) -> request::FetchParticipantRequest {
1397 request::FetchParticipantRequest {
1398 http_client: &self,
1399 account_sid: account_sid.to_owned(),
1400 call_sid: call_sid.to_owned(),
1401 conference_sid: conference_sid.to_owned(),
1402 }
1403 }
1404 pub fn update_participant(
1406 &self,
1407 account_sid: &str,
1408 call_sid: &str,
1409 conference_sid: &str,
1410 ) -> request::UpdateParticipantRequest {
1411 request::UpdateParticipantRequest {
1412 http_client: &self,
1413 account_sid: account_sid.to_owned(),
1414 call_sid: call_sid.to_owned(),
1415 conference_sid: conference_sid.to_owned(),
1416 }
1417 }
1418 pub fn delete_participant(
1420 &self,
1421 account_sid: &str,
1422 call_sid: &str,
1423 conference_sid: &str,
1424 ) -> request::DeleteParticipantRequest {
1425 request::DeleteParticipantRequest {
1426 http_client: &self,
1427 account_sid: account_sid.to_owned(),
1428 call_sid: call_sid.to_owned(),
1429 conference_sid: conference_sid.to_owned(),
1430 }
1431 }
1432 pub fn list_participant(
1434 &self,
1435 account_sid: &str,
1436 conference_sid: &str,
1437 ) -> request::ListParticipantRequest {
1438 request::ListParticipantRequest {
1439 http_client: &self,
1440 account_sid: account_sid.to_owned(),
1441 coaching: None,
1442 conference_sid: conference_sid.to_owned(),
1443 hold: None,
1444 muted: None,
1445 page: None,
1446 page_size: None,
1447 page_token: None,
1448 }
1449 }
1450 pub fn create_participant(
1451 &self,
1452 account_sid: &str,
1453 conference_sid: &str,
1454 ) -> request::CreateParticipantRequest {
1455 request::CreateParticipantRequest {
1456 http_client: &self,
1457 account_sid: account_sid.to_owned(),
1458 conference_sid: conference_sid.to_owned(),
1459 }
1460 }
1461 pub fn create_payments(
1463 &self,
1464 account_sid: &str,
1465 call_sid: &str,
1466 ) -> request::CreatePaymentsRequest {
1467 request::CreatePaymentsRequest {
1468 http_client: &self,
1469 account_sid: account_sid.to_owned(),
1470 call_sid: call_sid.to_owned(),
1471 }
1472 }
1473 pub fn update_payments(
1475 &self,
1476 account_sid: &str,
1477 call_sid: &str,
1478 sid: &str,
1479 ) -> request::UpdatePaymentsRequest {
1480 request::UpdatePaymentsRequest {
1481 http_client: &self,
1482 account_sid: account_sid.to_owned(),
1483 call_sid: call_sid.to_owned(),
1484 sid: sid.to_owned(),
1485 }
1486 }
1487 pub fn fetch_queue(
1489 &self,
1490 account_sid: &str,
1491 sid: &str,
1492 ) -> request::FetchQueueRequest {
1493 request::FetchQueueRequest {
1494 http_client: &self,
1495 account_sid: account_sid.to_owned(),
1496 sid: sid.to_owned(),
1497 }
1498 }
1499 pub fn update_queue(
1501 &self,
1502 account_sid: &str,
1503 sid: &str,
1504 ) -> request::UpdateQueueRequest {
1505 request::UpdateQueueRequest {
1506 http_client: &self,
1507 account_sid: account_sid.to_owned(),
1508 sid: sid.to_owned(),
1509 }
1510 }
1511 pub fn delete_queue(
1513 &self,
1514 account_sid: &str,
1515 sid: &str,
1516 ) -> request::DeleteQueueRequest {
1517 request::DeleteQueueRequest {
1518 http_client: &self,
1519 account_sid: account_sid.to_owned(),
1520 sid: sid.to_owned(),
1521 }
1522 }
1523 pub fn list_queue(&self, account_sid: &str) -> request::ListQueueRequest {
1525 request::ListQueueRequest {
1526 http_client: &self,
1527 account_sid: account_sid.to_owned(),
1528 page: None,
1529 page_size: None,
1530 page_token: None,
1531 }
1532 }
1533 pub fn create_queue(&self, account_sid: &str) -> request::CreateQueueRequest {
1535 request::CreateQueueRequest {
1536 http_client: &self,
1537 account_sid: account_sid.to_owned(),
1538 }
1539 }
1540 pub fn fetch_recording(
1542 &self,
1543 account_sid: &str,
1544 sid: &str,
1545 ) -> request::FetchRecordingRequest {
1546 request::FetchRecordingRequest {
1547 http_client: &self,
1548 account_sid: account_sid.to_owned(),
1549 include_soft_deleted: None,
1550 sid: sid.to_owned(),
1551 }
1552 }
1553 pub fn delete_recording(
1555 &self,
1556 account_sid: &str,
1557 sid: &str,
1558 ) -> request::DeleteRecordingRequest {
1559 request::DeleteRecordingRequest {
1560 http_client: &self,
1561 account_sid: account_sid.to_owned(),
1562 sid: sid.to_owned(),
1563 }
1564 }
1565 pub fn list_recording(&self, account_sid: &str) -> request::ListRecordingRequest {
1567 request::ListRecordingRequest {
1568 http_client: &self,
1569 account_sid: account_sid.to_owned(),
1570 call_sid: None,
1571 conference_sid: None,
1572 date_created: None,
1573 date_created_gt: None,
1574 date_created_lt: None,
1575 include_soft_deleted: None,
1576 page: None,
1577 page_size: None,
1578 page_token: None,
1579 }
1580 }
1581 pub fn fetch_recording_add_on_result(
1583 &self,
1584 account_sid: &str,
1585 reference_sid: &str,
1586 sid: &str,
1587 ) -> request::FetchRecordingAddOnResultRequest {
1588 request::FetchRecordingAddOnResultRequest {
1589 http_client: &self,
1590 account_sid: account_sid.to_owned(),
1591 reference_sid: reference_sid.to_owned(),
1592 sid: sid.to_owned(),
1593 }
1594 }
1595 pub fn delete_recording_add_on_result(
1597 &self,
1598 account_sid: &str,
1599 reference_sid: &str,
1600 sid: &str,
1601 ) -> request::DeleteRecordingAddOnResultRequest {
1602 request::DeleteRecordingAddOnResultRequest {
1603 http_client: &self,
1604 account_sid: account_sid.to_owned(),
1605 reference_sid: reference_sid.to_owned(),
1606 sid: sid.to_owned(),
1607 }
1608 }
1609 pub fn list_recording_add_on_result(
1611 &self,
1612 account_sid: &str,
1613 reference_sid: &str,
1614 ) -> request::ListRecordingAddOnResultRequest {
1615 request::ListRecordingAddOnResultRequest {
1616 http_client: &self,
1617 account_sid: account_sid.to_owned(),
1618 page: None,
1619 page_size: None,
1620 page_token: None,
1621 reference_sid: reference_sid.to_owned(),
1622 }
1623 }
1624 pub fn fetch_recording_add_on_result_payload(
1626 &self,
1627 args: request::FetchRecordingAddOnResultPayloadRequired,
1628 ) -> request::FetchRecordingAddOnResultPayloadRequest {
1629 request::FetchRecordingAddOnResultPayloadRequest {
1630 http_client: &self,
1631 account_sid: args.account_sid.to_owned(),
1632 add_on_result_sid: args.add_on_result_sid.to_owned(),
1633 reference_sid: args.reference_sid.to_owned(),
1634 sid: args.sid.to_owned(),
1635 }
1636 }
1637 pub fn delete_recording_add_on_result_payload(
1639 &self,
1640 args: request::DeleteRecordingAddOnResultPayloadRequired,
1641 ) -> request::DeleteRecordingAddOnResultPayloadRequest {
1642 request::DeleteRecordingAddOnResultPayloadRequest {
1643 http_client: &self,
1644 account_sid: args.account_sid.to_owned(),
1645 add_on_result_sid: args.add_on_result_sid.to_owned(),
1646 reference_sid: args.reference_sid.to_owned(),
1647 sid: args.sid.to_owned(),
1648 }
1649 }
1650 pub fn list_recording_add_on_result_payload(
1652 &self,
1653 account_sid: &str,
1654 add_on_result_sid: &str,
1655 reference_sid: &str,
1656 ) -> request::ListRecordingAddOnResultPayloadRequest {
1657 request::ListRecordingAddOnResultPayloadRequest {
1658 http_client: &self,
1659 account_sid: account_sid.to_owned(),
1660 add_on_result_sid: add_on_result_sid.to_owned(),
1661 page: None,
1662 page_size: None,
1663 page_token: None,
1664 reference_sid: reference_sid.to_owned(),
1665 }
1666 }
1667 pub fn fetch_recording_transcription(
1668 &self,
1669 account_sid: &str,
1670 recording_sid: &str,
1671 sid: &str,
1672 ) -> request::FetchRecordingTranscriptionRequest {
1673 request::FetchRecordingTranscriptionRequest {
1674 http_client: &self,
1675 account_sid: account_sid.to_owned(),
1676 recording_sid: recording_sid.to_owned(),
1677 sid: sid.to_owned(),
1678 }
1679 }
1680 pub fn delete_recording_transcription(
1681 &self,
1682 account_sid: &str,
1683 recording_sid: &str,
1684 sid: &str,
1685 ) -> request::DeleteRecordingTranscriptionRequest {
1686 request::DeleteRecordingTranscriptionRequest {
1687 http_client: &self,
1688 account_sid: account_sid.to_owned(),
1689 recording_sid: recording_sid.to_owned(),
1690 sid: sid.to_owned(),
1691 }
1692 }
1693 pub fn list_recording_transcription(
1694 &self,
1695 account_sid: &str,
1696 recording_sid: &str,
1697 ) -> request::ListRecordingTranscriptionRequest {
1698 request::ListRecordingTranscriptionRequest {
1699 http_client: &self,
1700 account_sid: account_sid.to_owned(),
1701 page: None,
1702 page_size: None,
1703 page_token: None,
1704 recording_sid: recording_sid.to_owned(),
1705 }
1706 }
1707 pub fn fetch_short_code(
1709 &self,
1710 account_sid: &str,
1711 sid: &str,
1712 ) -> request::FetchShortCodeRequest {
1713 request::FetchShortCodeRequest {
1714 http_client: &self,
1715 account_sid: account_sid.to_owned(),
1716 sid: sid.to_owned(),
1717 }
1718 }
1719 pub fn update_short_code(
1721 &self,
1722 account_sid: &str,
1723 sid: &str,
1724 ) -> request::UpdateShortCodeRequest {
1725 request::UpdateShortCodeRequest {
1726 http_client: &self,
1727 account_sid: account_sid.to_owned(),
1728 sid: sid.to_owned(),
1729 }
1730 }
1731 pub fn list_short_code(&self, account_sid: &str) -> request::ListShortCodeRequest {
1733 request::ListShortCodeRequest {
1734 http_client: &self,
1735 account_sid: account_sid.to_owned(),
1736 friendly_name: None,
1737 page: None,
1738 page_size: None,
1739 page_token: None,
1740 short_code: None,
1741 }
1742 }
1743 pub fn fetch_signing_key(
1744 &self,
1745 account_sid: &str,
1746 sid: &str,
1747 ) -> request::FetchSigningKeyRequest {
1748 request::FetchSigningKeyRequest {
1749 http_client: &self,
1750 account_sid: account_sid.to_owned(),
1751 sid: sid.to_owned(),
1752 }
1753 }
1754 pub fn update_signing_key(
1755 &self,
1756 account_sid: &str,
1757 sid: &str,
1758 ) -> request::UpdateSigningKeyRequest {
1759 request::UpdateSigningKeyRequest {
1760 http_client: &self,
1761 account_sid: account_sid.to_owned(),
1762 sid: sid.to_owned(),
1763 }
1764 }
1765 pub fn delete_signing_key(
1766 &self,
1767 account_sid: &str,
1768 sid: &str,
1769 ) -> request::DeleteSigningKeyRequest {
1770 request::DeleteSigningKeyRequest {
1771 http_client: &self,
1772 account_sid: account_sid.to_owned(),
1773 sid: sid.to_owned(),
1774 }
1775 }
1776 pub fn list_sip_auth_calls_credential_list_mapping(
1778 &self,
1779 account_sid: &str,
1780 domain_sid: &str,
1781 ) -> request::ListSipAuthCallsCredentialListMappingRequest {
1782 request::ListSipAuthCallsCredentialListMappingRequest {
1783 http_client: &self,
1784 account_sid: account_sid.to_owned(),
1785 domain_sid: domain_sid.to_owned(),
1786 page: None,
1787 page_size: None,
1788 page_token: None,
1789 }
1790 }
1791 pub fn create_sip_auth_calls_credential_list_mapping(
1793 &self,
1794 account_sid: &str,
1795 domain_sid: &str,
1796 ) -> request::CreateSipAuthCallsCredentialListMappingRequest {
1797 request::CreateSipAuthCallsCredentialListMappingRequest {
1798 http_client: &self,
1799 account_sid: account_sid.to_owned(),
1800 domain_sid: domain_sid.to_owned(),
1801 }
1802 }
1803 pub fn fetch_sip_auth_calls_credential_list_mapping(
1805 &self,
1806 account_sid: &str,
1807 domain_sid: &str,
1808 sid: &str,
1809 ) -> request::FetchSipAuthCallsCredentialListMappingRequest {
1810 request::FetchSipAuthCallsCredentialListMappingRequest {
1811 http_client: &self,
1812 account_sid: account_sid.to_owned(),
1813 domain_sid: domain_sid.to_owned(),
1814 sid: sid.to_owned(),
1815 }
1816 }
1817 pub fn delete_sip_auth_calls_credential_list_mapping(
1819 &self,
1820 account_sid: &str,
1821 domain_sid: &str,
1822 sid: &str,
1823 ) -> request::DeleteSipAuthCallsCredentialListMappingRequest {
1824 request::DeleteSipAuthCallsCredentialListMappingRequest {
1825 http_client: &self,
1826 account_sid: account_sid.to_owned(),
1827 domain_sid: domain_sid.to_owned(),
1828 sid: sid.to_owned(),
1829 }
1830 }
1831 pub fn list_sip_auth_calls_ip_access_control_list_mapping(
1833 &self,
1834 account_sid: &str,
1835 domain_sid: &str,
1836 ) -> request::ListSipAuthCallsIpAccessControlListMappingRequest {
1837 request::ListSipAuthCallsIpAccessControlListMappingRequest {
1838 http_client: &self,
1839 account_sid: account_sid.to_owned(),
1840 domain_sid: domain_sid.to_owned(),
1841 page: None,
1842 page_size: None,
1843 page_token: None,
1844 }
1845 }
1846 pub fn create_sip_auth_calls_ip_access_control_list_mapping(
1848 &self,
1849 account_sid: &str,
1850 domain_sid: &str,
1851 ) -> request::CreateSipAuthCallsIpAccessControlListMappingRequest {
1852 request::CreateSipAuthCallsIpAccessControlListMappingRequest {
1853 http_client: &self,
1854 account_sid: account_sid.to_owned(),
1855 domain_sid: domain_sid.to_owned(),
1856 }
1857 }
1858 pub fn fetch_sip_auth_calls_ip_access_control_list_mapping(
1860 &self,
1861 account_sid: &str,
1862 domain_sid: &str,
1863 sid: &str,
1864 ) -> request::FetchSipAuthCallsIpAccessControlListMappingRequest {
1865 request::FetchSipAuthCallsIpAccessControlListMappingRequest {
1866 http_client: &self,
1867 account_sid: account_sid.to_owned(),
1868 domain_sid: domain_sid.to_owned(),
1869 sid: sid.to_owned(),
1870 }
1871 }
1872 pub fn delete_sip_auth_calls_ip_access_control_list_mapping(
1874 &self,
1875 account_sid: &str,
1876 domain_sid: &str,
1877 sid: &str,
1878 ) -> request::DeleteSipAuthCallsIpAccessControlListMappingRequest {
1879 request::DeleteSipAuthCallsIpAccessControlListMappingRequest {
1880 http_client: &self,
1881 account_sid: account_sid.to_owned(),
1882 domain_sid: domain_sid.to_owned(),
1883 sid: sid.to_owned(),
1884 }
1885 }
1886 pub fn list_sip_auth_registrations_credential_list_mapping(
1888 &self,
1889 account_sid: &str,
1890 domain_sid: &str,
1891 ) -> request::ListSipAuthRegistrationsCredentialListMappingRequest {
1892 request::ListSipAuthRegistrationsCredentialListMappingRequest {
1893 http_client: &self,
1894 account_sid: account_sid.to_owned(),
1895 domain_sid: domain_sid.to_owned(),
1896 page: None,
1897 page_size: None,
1898 page_token: None,
1899 }
1900 }
1901 pub fn create_sip_auth_registrations_credential_list_mapping(
1903 &self,
1904 account_sid: &str,
1905 domain_sid: &str,
1906 ) -> request::CreateSipAuthRegistrationsCredentialListMappingRequest {
1907 request::CreateSipAuthRegistrationsCredentialListMappingRequest {
1908 http_client: &self,
1909 account_sid: account_sid.to_owned(),
1910 domain_sid: domain_sid.to_owned(),
1911 }
1912 }
1913 pub fn fetch_sip_auth_registrations_credential_list_mapping(
1915 &self,
1916 account_sid: &str,
1917 domain_sid: &str,
1918 sid: &str,
1919 ) -> request::FetchSipAuthRegistrationsCredentialListMappingRequest {
1920 request::FetchSipAuthRegistrationsCredentialListMappingRequest {
1921 http_client: &self,
1922 account_sid: account_sid.to_owned(),
1923 domain_sid: domain_sid.to_owned(),
1924 sid: sid.to_owned(),
1925 }
1926 }
1927 pub fn delete_sip_auth_registrations_credential_list_mapping(
1929 &self,
1930 account_sid: &str,
1931 domain_sid: &str,
1932 sid: &str,
1933 ) -> request::DeleteSipAuthRegistrationsCredentialListMappingRequest {
1934 request::DeleteSipAuthRegistrationsCredentialListMappingRequest {
1935 http_client: &self,
1936 account_sid: account_sid.to_owned(),
1937 domain_sid: domain_sid.to_owned(),
1938 sid: sid.to_owned(),
1939 }
1940 }
1941 pub fn list_sip_credential(
1943 &self,
1944 account_sid: &str,
1945 credential_list_sid: &str,
1946 ) -> request::ListSipCredentialRequest {
1947 request::ListSipCredentialRequest {
1948 http_client: &self,
1949 account_sid: account_sid.to_owned(),
1950 credential_list_sid: credential_list_sid.to_owned(),
1951 page: None,
1952 page_size: None,
1953 page_token: None,
1954 }
1955 }
1956 pub fn create_sip_credential(
1958 &self,
1959 account_sid: &str,
1960 credential_list_sid: &str,
1961 ) -> request::CreateSipCredentialRequest {
1962 request::CreateSipCredentialRequest {
1963 http_client: &self,
1964 account_sid: account_sid.to_owned(),
1965 credential_list_sid: credential_list_sid.to_owned(),
1966 }
1967 }
1968 pub fn fetch_sip_credential(
1970 &self,
1971 account_sid: &str,
1972 credential_list_sid: &str,
1973 sid: &str,
1974 ) -> request::FetchSipCredentialRequest {
1975 request::FetchSipCredentialRequest {
1976 http_client: &self,
1977 account_sid: account_sid.to_owned(),
1978 credential_list_sid: credential_list_sid.to_owned(),
1979 sid: sid.to_owned(),
1980 }
1981 }
1982 pub fn update_sip_credential(
1984 &self,
1985 account_sid: &str,
1986 credential_list_sid: &str,
1987 sid: &str,
1988 ) -> request::UpdateSipCredentialRequest {
1989 request::UpdateSipCredentialRequest {
1990 http_client: &self,
1991 account_sid: account_sid.to_owned(),
1992 credential_list_sid: credential_list_sid.to_owned(),
1993 sid: sid.to_owned(),
1994 }
1995 }
1996 pub fn delete_sip_credential(
1998 &self,
1999 account_sid: &str,
2000 credential_list_sid: &str,
2001 sid: &str,
2002 ) -> request::DeleteSipCredentialRequest {
2003 request::DeleteSipCredentialRequest {
2004 http_client: &self,
2005 account_sid: account_sid.to_owned(),
2006 credential_list_sid: credential_list_sid.to_owned(),
2007 sid: sid.to_owned(),
2008 }
2009 }
2010 pub fn list_sip_credential_list(
2012 &self,
2013 account_sid: &str,
2014 ) -> request::ListSipCredentialListRequest {
2015 request::ListSipCredentialListRequest {
2016 http_client: &self,
2017 account_sid: account_sid.to_owned(),
2018 page: None,
2019 page_size: None,
2020 page_token: None,
2021 }
2022 }
2023 pub fn create_sip_credential_list(
2025 &self,
2026 account_sid: &str,
2027 ) -> request::CreateSipCredentialListRequest {
2028 request::CreateSipCredentialListRequest {
2029 http_client: &self,
2030 account_sid: account_sid.to_owned(),
2031 }
2032 }
2033 pub fn fetch_sip_credential_list(
2035 &self,
2036 account_sid: &str,
2037 sid: &str,
2038 ) -> request::FetchSipCredentialListRequest {
2039 request::FetchSipCredentialListRequest {
2040 http_client: &self,
2041 account_sid: account_sid.to_owned(),
2042 sid: sid.to_owned(),
2043 }
2044 }
2045 pub fn update_sip_credential_list(
2047 &self,
2048 account_sid: &str,
2049 sid: &str,
2050 ) -> request::UpdateSipCredentialListRequest {
2051 request::UpdateSipCredentialListRequest {
2052 http_client: &self,
2053 account_sid: account_sid.to_owned(),
2054 sid: sid.to_owned(),
2055 }
2056 }
2057 pub fn delete_sip_credential_list(
2059 &self,
2060 account_sid: &str,
2061 sid: &str,
2062 ) -> request::DeleteSipCredentialListRequest {
2063 request::DeleteSipCredentialListRequest {
2064 http_client: &self,
2065 account_sid: account_sid.to_owned(),
2066 sid: sid.to_owned(),
2067 }
2068 }
2069 pub fn list_sip_credential_list_mapping(
2071 &self,
2072 account_sid: &str,
2073 domain_sid: &str,
2074 ) -> request::ListSipCredentialListMappingRequest {
2075 request::ListSipCredentialListMappingRequest {
2076 http_client: &self,
2077 account_sid: account_sid.to_owned(),
2078 domain_sid: domain_sid.to_owned(),
2079 page: None,
2080 page_size: None,
2081 page_token: None,
2082 }
2083 }
2084 pub fn create_sip_credential_list_mapping(
2086 &self,
2087 account_sid: &str,
2088 domain_sid: &str,
2089 ) -> request::CreateSipCredentialListMappingRequest {
2090 request::CreateSipCredentialListMappingRequest {
2091 http_client: &self,
2092 account_sid: account_sid.to_owned(),
2093 domain_sid: domain_sid.to_owned(),
2094 }
2095 }
2096 pub fn fetch_sip_credential_list_mapping(
2098 &self,
2099 account_sid: &str,
2100 domain_sid: &str,
2101 sid: &str,
2102 ) -> request::FetchSipCredentialListMappingRequest {
2103 request::FetchSipCredentialListMappingRequest {
2104 http_client: &self,
2105 account_sid: account_sid.to_owned(),
2106 domain_sid: domain_sid.to_owned(),
2107 sid: sid.to_owned(),
2108 }
2109 }
2110 pub fn delete_sip_credential_list_mapping(
2112 &self,
2113 account_sid: &str,
2114 domain_sid: &str,
2115 sid: &str,
2116 ) -> request::DeleteSipCredentialListMappingRequest {
2117 request::DeleteSipCredentialListMappingRequest {
2118 http_client: &self,
2119 account_sid: account_sid.to_owned(),
2120 domain_sid: domain_sid.to_owned(),
2121 sid: sid.to_owned(),
2122 }
2123 }
2124 pub fn list_sip_domain(&self, account_sid: &str) -> request::ListSipDomainRequest {
2126 request::ListSipDomainRequest {
2127 http_client: &self,
2128 account_sid: account_sid.to_owned(),
2129 page: None,
2130 page_size: None,
2131 page_token: None,
2132 }
2133 }
2134 pub fn create_sip_domain(
2136 &self,
2137 account_sid: &str,
2138 ) -> request::CreateSipDomainRequest {
2139 request::CreateSipDomainRequest {
2140 http_client: &self,
2141 account_sid: account_sid.to_owned(),
2142 }
2143 }
2144 pub fn fetch_sip_domain(
2146 &self,
2147 account_sid: &str,
2148 sid: &str,
2149 ) -> request::FetchSipDomainRequest {
2150 request::FetchSipDomainRequest {
2151 http_client: &self,
2152 account_sid: account_sid.to_owned(),
2153 sid: sid.to_owned(),
2154 }
2155 }
2156 pub fn update_sip_domain(
2158 &self,
2159 account_sid: &str,
2160 sid: &str,
2161 ) -> request::UpdateSipDomainRequest {
2162 request::UpdateSipDomainRequest {
2163 http_client: &self,
2164 account_sid: account_sid.to_owned(),
2165 sid: sid.to_owned(),
2166 }
2167 }
2168 pub fn delete_sip_domain(
2170 &self,
2171 account_sid: &str,
2172 sid: &str,
2173 ) -> request::DeleteSipDomainRequest {
2174 request::DeleteSipDomainRequest {
2175 http_client: &self,
2176 account_sid: account_sid.to_owned(),
2177 sid: sid.to_owned(),
2178 }
2179 }
2180 pub fn list_sip_ip_access_control_list(
2182 &self,
2183 account_sid: &str,
2184 ) -> request::ListSipIpAccessControlListRequest {
2185 request::ListSipIpAccessControlListRequest {
2186 http_client: &self,
2187 account_sid: account_sid.to_owned(),
2188 page: None,
2189 page_size: None,
2190 page_token: None,
2191 }
2192 }
2193 pub fn create_sip_ip_access_control_list(
2195 &self,
2196 account_sid: &str,
2197 ) -> request::CreateSipIpAccessControlListRequest {
2198 request::CreateSipIpAccessControlListRequest {
2199 http_client: &self,
2200 account_sid: account_sid.to_owned(),
2201 }
2202 }
2203 pub fn fetch_sip_ip_access_control_list(
2205 &self,
2206 account_sid: &str,
2207 sid: &str,
2208 ) -> request::FetchSipIpAccessControlListRequest {
2209 request::FetchSipIpAccessControlListRequest {
2210 http_client: &self,
2211 account_sid: account_sid.to_owned(),
2212 sid: sid.to_owned(),
2213 }
2214 }
2215 pub fn update_sip_ip_access_control_list(
2217 &self,
2218 account_sid: &str,
2219 sid: &str,
2220 ) -> request::UpdateSipIpAccessControlListRequest {
2221 request::UpdateSipIpAccessControlListRequest {
2222 http_client: &self,
2223 account_sid: account_sid.to_owned(),
2224 sid: sid.to_owned(),
2225 }
2226 }
2227 pub fn delete_sip_ip_access_control_list(
2229 &self,
2230 account_sid: &str,
2231 sid: &str,
2232 ) -> request::DeleteSipIpAccessControlListRequest {
2233 request::DeleteSipIpAccessControlListRequest {
2234 http_client: &self,
2235 account_sid: account_sid.to_owned(),
2236 sid: sid.to_owned(),
2237 }
2238 }
2239 pub fn fetch_sip_ip_access_control_list_mapping(
2241 &self,
2242 account_sid: &str,
2243 domain_sid: &str,
2244 sid: &str,
2245 ) -> request::FetchSipIpAccessControlListMappingRequest {
2246 request::FetchSipIpAccessControlListMappingRequest {
2247 http_client: &self,
2248 account_sid: account_sid.to_owned(),
2249 domain_sid: domain_sid.to_owned(),
2250 sid: sid.to_owned(),
2251 }
2252 }
2253 pub fn delete_sip_ip_access_control_list_mapping(
2255 &self,
2256 account_sid: &str,
2257 domain_sid: &str,
2258 sid: &str,
2259 ) -> request::DeleteSipIpAccessControlListMappingRequest {
2260 request::DeleteSipIpAccessControlListMappingRequest {
2261 http_client: &self,
2262 account_sid: account_sid.to_owned(),
2263 domain_sid: domain_sid.to_owned(),
2264 sid: sid.to_owned(),
2265 }
2266 }
2267 pub fn list_sip_ip_access_control_list_mapping(
2269 &self,
2270 account_sid: &str,
2271 domain_sid: &str,
2272 ) -> request::ListSipIpAccessControlListMappingRequest {
2273 request::ListSipIpAccessControlListMappingRequest {
2274 http_client: &self,
2275 account_sid: account_sid.to_owned(),
2276 domain_sid: domain_sid.to_owned(),
2277 page: None,
2278 page_size: None,
2279 page_token: None,
2280 }
2281 }
2282 pub fn create_sip_ip_access_control_list_mapping(
2284 &self,
2285 account_sid: &str,
2286 domain_sid: &str,
2287 ) -> request::CreateSipIpAccessControlListMappingRequest {
2288 request::CreateSipIpAccessControlListMappingRequest {
2289 http_client: &self,
2290 account_sid: account_sid.to_owned(),
2291 domain_sid: domain_sid.to_owned(),
2292 }
2293 }
2294 pub fn list_sip_ip_address(
2296 &self,
2297 account_sid: &str,
2298 ip_access_control_list_sid: &str,
2299 ) -> request::ListSipIpAddressRequest {
2300 request::ListSipIpAddressRequest {
2301 http_client: &self,
2302 account_sid: account_sid.to_owned(),
2303 ip_access_control_list_sid: ip_access_control_list_sid.to_owned(),
2304 page: None,
2305 page_size: None,
2306 page_token: None,
2307 }
2308 }
2309 pub fn create_sip_ip_address(
2311 &self,
2312 account_sid: &str,
2313 ip_access_control_list_sid: &str,
2314 ) -> request::CreateSipIpAddressRequest {
2315 request::CreateSipIpAddressRequest {
2316 http_client: &self,
2317 account_sid: account_sid.to_owned(),
2318 ip_access_control_list_sid: ip_access_control_list_sid.to_owned(),
2319 }
2320 }
2321 pub fn fetch_sip_ip_address(
2323 &self,
2324 account_sid: &str,
2325 ip_access_control_list_sid: &str,
2326 sid: &str,
2327 ) -> request::FetchSipIpAddressRequest {
2328 request::FetchSipIpAddressRequest {
2329 http_client: &self,
2330 account_sid: account_sid.to_owned(),
2331 ip_access_control_list_sid: ip_access_control_list_sid.to_owned(),
2332 sid: sid.to_owned(),
2333 }
2334 }
2335 pub fn update_sip_ip_address(
2337 &self,
2338 account_sid: &str,
2339 ip_access_control_list_sid: &str,
2340 sid: &str,
2341 ) -> request::UpdateSipIpAddressRequest {
2342 request::UpdateSipIpAddressRequest {
2343 http_client: &self,
2344 account_sid: account_sid.to_owned(),
2345 ip_access_control_list_sid: ip_access_control_list_sid.to_owned(),
2346 sid: sid.to_owned(),
2347 }
2348 }
2349 pub fn delete_sip_ip_address(
2351 &self,
2352 account_sid: &str,
2353 ip_access_control_list_sid: &str,
2354 sid: &str,
2355 ) -> request::DeleteSipIpAddressRequest {
2356 request::DeleteSipIpAddressRequest {
2357 http_client: &self,
2358 account_sid: account_sid.to_owned(),
2359 ip_access_control_list_sid: ip_access_control_list_sid.to_owned(),
2360 sid: sid.to_owned(),
2361 }
2362 }
2363 pub fn create_siprec(
2365 &self,
2366 account_sid: &str,
2367 call_sid: &str,
2368 ) -> request::CreateSiprecRequest {
2369 request::CreateSiprecRequest {
2370 http_client: &self,
2371 account_sid: account_sid.to_owned(),
2372 call_sid: call_sid.to_owned(),
2373 }
2374 }
2375 pub fn update_siprec(
2377 &self,
2378 account_sid: &str,
2379 call_sid: &str,
2380 sid: &str,
2381 ) -> request::UpdateSiprecRequest {
2382 request::UpdateSiprecRequest {
2383 http_client: &self,
2384 account_sid: account_sid.to_owned(),
2385 call_sid: call_sid.to_owned(),
2386 sid: sid.to_owned(),
2387 }
2388 }
2389 pub fn create_stream(
2391 &self,
2392 account_sid: &str,
2393 call_sid: &str,
2394 ) -> request::CreateStreamRequest {
2395 request::CreateStreamRequest {
2396 http_client: &self,
2397 account_sid: account_sid.to_owned(),
2398 call_sid: call_sid.to_owned(),
2399 }
2400 }
2401 pub fn update_stream(
2403 &self,
2404 account_sid: &str,
2405 call_sid: &str,
2406 sid: &str,
2407 ) -> request::UpdateStreamRequest {
2408 request::UpdateStreamRequest {
2409 http_client: &self,
2410 account_sid: account_sid.to_owned(),
2411 call_sid: call_sid.to_owned(),
2412 sid: sid.to_owned(),
2413 }
2414 }
2415 pub fn create_token(&self, account_sid: &str) -> request::CreateTokenRequest {
2417 request::CreateTokenRequest {
2418 http_client: &self,
2419 account_sid: account_sid.to_owned(),
2420 }
2421 }
2422 pub fn fetch_transcription(
2424 &self,
2425 account_sid: &str,
2426 sid: &str,
2427 ) -> request::FetchTranscriptionRequest {
2428 request::FetchTranscriptionRequest {
2429 http_client: &self,
2430 account_sid: account_sid.to_owned(),
2431 sid: sid.to_owned(),
2432 }
2433 }
2434 pub fn delete_transcription(
2436 &self,
2437 account_sid: &str,
2438 sid: &str,
2439 ) -> request::DeleteTranscriptionRequest {
2440 request::DeleteTranscriptionRequest {
2441 http_client: &self,
2442 account_sid: account_sid.to_owned(),
2443 sid: sid.to_owned(),
2444 }
2445 }
2446 pub fn list_transcription(
2448 &self,
2449 account_sid: &str,
2450 ) -> request::ListTranscriptionRequest {
2451 request::ListTranscriptionRequest {
2452 http_client: &self,
2453 account_sid: account_sid.to_owned(),
2454 page: None,
2455 page_size: None,
2456 page_token: None,
2457 }
2458 }
2459 pub fn list_usage_record(
2461 &self,
2462 account_sid: &str,
2463 ) -> request::ListUsageRecordRequest {
2464 request::ListUsageRecordRequest {
2465 http_client: &self,
2466 account_sid: account_sid.to_owned(),
2467 category: None,
2468 end_date: None,
2469 include_subaccounts: None,
2470 page: None,
2471 page_size: None,
2472 page_token: None,
2473 start_date: None,
2474 }
2475 }
2476 pub fn list_usage_record_all_time(
2477 &self,
2478 account_sid: &str,
2479 ) -> request::ListUsageRecordAllTimeRequest {
2480 request::ListUsageRecordAllTimeRequest {
2481 http_client: &self,
2482 account_sid: account_sid.to_owned(),
2483 category: None,
2484 end_date: None,
2485 include_subaccounts: None,
2486 page: None,
2487 page_size: None,
2488 page_token: None,
2489 start_date: None,
2490 }
2491 }
2492 pub fn list_usage_record_daily(
2493 &self,
2494 account_sid: &str,
2495 ) -> request::ListUsageRecordDailyRequest {
2496 request::ListUsageRecordDailyRequest {
2497 http_client: &self,
2498 account_sid: account_sid.to_owned(),
2499 category: None,
2500 end_date: None,
2501 include_subaccounts: None,
2502 page: None,
2503 page_size: None,
2504 page_token: None,
2505 start_date: None,
2506 }
2507 }
2508 pub fn list_usage_record_last_month(
2509 &self,
2510 account_sid: &str,
2511 ) -> request::ListUsageRecordLastMonthRequest {
2512 request::ListUsageRecordLastMonthRequest {
2513 http_client: &self,
2514 account_sid: account_sid.to_owned(),
2515 category: None,
2516 end_date: None,
2517 include_subaccounts: None,
2518 page: None,
2519 page_size: None,
2520 page_token: None,
2521 start_date: None,
2522 }
2523 }
2524 pub fn list_usage_record_monthly(
2525 &self,
2526 account_sid: &str,
2527 ) -> request::ListUsageRecordMonthlyRequest {
2528 request::ListUsageRecordMonthlyRequest {
2529 http_client: &self,
2530 account_sid: account_sid.to_owned(),
2531 category: None,
2532 end_date: None,
2533 include_subaccounts: None,
2534 page: None,
2535 page_size: None,
2536 page_token: None,
2537 start_date: None,
2538 }
2539 }
2540 pub fn list_usage_record_this_month(
2541 &self,
2542 account_sid: &str,
2543 ) -> request::ListUsageRecordThisMonthRequest {
2544 request::ListUsageRecordThisMonthRequest {
2545 http_client: &self,
2546 account_sid: account_sid.to_owned(),
2547 category: None,
2548 end_date: None,
2549 include_subaccounts: None,
2550 page: None,
2551 page_size: None,
2552 page_token: None,
2553 start_date: None,
2554 }
2555 }
2556 pub fn list_usage_record_today(
2557 &self,
2558 account_sid: &str,
2559 ) -> request::ListUsageRecordTodayRequest {
2560 request::ListUsageRecordTodayRequest {
2561 http_client: &self,
2562 account_sid: account_sid.to_owned(),
2563 category: None,
2564 end_date: None,
2565 include_subaccounts: None,
2566 page: None,
2567 page_size: None,
2568 page_token: None,
2569 start_date: None,
2570 }
2571 }
2572 pub fn list_usage_record_yearly(
2573 &self,
2574 account_sid: &str,
2575 ) -> request::ListUsageRecordYearlyRequest {
2576 request::ListUsageRecordYearlyRequest {
2577 http_client: &self,
2578 account_sid: account_sid.to_owned(),
2579 category: None,
2580 end_date: None,
2581 include_subaccounts: None,
2582 page: None,
2583 page_size: None,
2584 page_token: None,
2585 start_date: None,
2586 }
2587 }
2588 pub fn list_usage_record_yesterday(
2589 &self,
2590 account_sid: &str,
2591 ) -> request::ListUsageRecordYesterdayRequest {
2592 request::ListUsageRecordYesterdayRequest {
2593 http_client: &self,
2594 account_sid: account_sid.to_owned(),
2595 category: None,
2596 end_date: None,
2597 include_subaccounts: None,
2598 page: None,
2599 page_size: None,
2600 page_token: None,
2601 start_date: None,
2602 }
2603 }
2604 pub fn fetch_usage_trigger(
2606 &self,
2607 account_sid: &str,
2608 sid: &str,
2609 ) -> request::FetchUsageTriggerRequest {
2610 request::FetchUsageTriggerRequest {
2611 http_client: &self,
2612 account_sid: account_sid.to_owned(),
2613 sid: sid.to_owned(),
2614 }
2615 }
2616 pub fn update_usage_trigger(
2618 &self,
2619 account_sid: &str,
2620 sid: &str,
2621 ) -> request::UpdateUsageTriggerRequest {
2622 request::UpdateUsageTriggerRequest {
2623 http_client: &self,
2624 account_sid: account_sid.to_owned(),
2625 sid: sid.to_owned(),
2626 }
2627 }
2628 pub fn delete_usage_trigger(
2629 &self,
2630 account_sid: &str,
2631 sid: &str,
2632 ) -> request::DeleteUsageTriggerRequest {
2633 request::DeleteUsageTriggerRequest {
2634 http_client: &self,
2635 account_sid: account_sid.to_owned(),
2636 sid: sid.to_owned(),
2637 }
2638 }
2639 pub fn list_usage_trigger(
2641 &self,
2642 account_sid: &str,
2643 ) -> request::ListUsageTriggerRequest {
2644 request::ListUsageTriggerRequest {
2645 http_client: &self,
2646 account_sid: account_sid.to_owned(),
2647 page: None,
2648 page_size: None,
2649 page_token: None,
2650 recurring: None,
2651 trigger_by: None,
2652 usage_category: None,
2653 }
2654 }
2655 pub fn create_usage_trigger(
2657 &self,
2658 account_sid: &str,
2659 ) -> request::CreateUsageTriggerRequest {
2660 request::CreateUsageTriggerRequest {
2661 http_client: &self,
2662 account_sid: account_sid.to_owned(),
2663 }
2664 }
2665 pub fn create_user_defined_message(
2667 &self,
2668 account_sid: &str,
2669 call_sid: &str,
2670 ) -> request::CreateUserDefinedMessageRequest {
2671 request::CreateUserDefinedMessageRequest {
2672 http_client: &self,
2673 account_sid: account_sid.to_owned(),
2674 call_sid: call_sid.to_owned(),
2675 }
2676 }
2677 pub fn create_user_defined_message_subscription(
2679 &self,
2680 account_sid: &str,
2681 call_sid: &str,
2682 ) -> request::CreateUserDefinedMessageSubscriptionRequest {
2683 request::CreateUserDefinedMessageSubscriptionRequest {
2684 http_client: &self,
2685 account_sid: account_sid.to_owned(),
2686 call_sid: call_sid.to_owned(),
2687 }
2688 }
2689 pub fn delete_user_defined_message_subscription(
2691 &self,
2692 account_sid: &str,
2693 call_sid: &str,
2694 sid: &str,
2695 ) -> request::DeleteUserDefinedMessageSubscriptionRequest {
2696 request::DeleteUserDefinedMessageSubscriptionRequest {
2697 http_client: &self,
2698 account_sid: account_sid.to_owned(),
2699 call_sid: call_sid.to_owned(),
2700 sid: sid.to_owned(),
2701 }
2702 }
2703}
2704pub enum TwilioAuthentication {
2705 BasicAuth { basic_auth: String },
2706}
2707impl TwilioAuthentication {
2708 pub fn from_env() -> Self {
2709 Self::BasicAuth {
2710 basic_auth: std::env::var("TWILIO_BASIC_AUTH")
2711 .expect("Environment variable TWILIO_BASIC_AUTH is not set."),
2712 }
2713 }
2714}