1use schemars::JsonSchema;
3use serde::{Deserialize, Serialize};
4
5#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
7pub struct Details {}
8
9#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
10pub struct Error {
11 #[serde(default, skip_serializing_if = "Option::is_none")]
15 pub details: Option<Details>,
16 #[serde(
20 default,
21 skip_serializing_if = "String::is_empty",
22 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
23 )]
24 pub message: String,
25}
26
27#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
28pub struct ErrorResponse {
29 #[serde(default, skip_serializing_if = "Option::is_none")]
30 pub error: Option<Error>,
31}
32
33#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
34pub struct TaskResponse {
35 #[serde(
39 default,
40 skip_serializing_if = "String::is_empty",
41 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
42 )]
43 pub id: String,
44}
45
46#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
47pub enum Role {
48 #[serde(rename = "BUSINESS_ADMIN")]
49 BusinessAdmin,
50 #[serde(rename = "BUSINESS_BOOKKEEPER")]
51 BusinessBookkeeper,
52 #[serde(rename = "BUSINESS_OWNER")]
53 BusinessOwner,
54 #[serde(rename = "BUSINESS_USER")]
55 BusinessUser,
56 #[serde(rename = "")]
57 #[default]
58 Noop,
59 #[serde(other)]
60 FallthroughString,
61}
62
63impl std::fmt::Display for Role {
64 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
65 match self {
66 Role::BusinessAdmin => "BUSINESS_ADMIN",
67 Role::BusinessBookkeeper => "BUSINESS_BOOKKEEPER",
68 Role::BusinessOwner => "BUSINESS_OWNER",
69 Role::BusinessUser => "BUSINESS_USER",
70 Role::Noop => "",
71 Role::FallthroughString => "*",
72 }
73 .fmt(f)
74 }
75}
76
77impl Role {
78 pub fn is_noop(&self) -> bool {
79 matches!(self, Role::Noop)
80 }
81}
82
83#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
85pub struct User {
86 #[serde(
90 default,
91 skip_serializing_if = "String::is_empty",
92 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
93 )]
94 pub amount_limit: String,
95 #[serde(
99 default,
100 skip_serializing_if = "String::is_empty",
101 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
102 )]
103 pub business_id: String,
104 #[serde(
108 default,
109 skip_serializing_if = "String::is_empty",
110 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
111 )]
112 pub department_id: String,
113 #[serde(
117 default,
118 skip_serializing_if = "String::is_empty",
119 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
120 )]
121 pub email: String,
122 #[serde(
126 default,
127 skip_serializing_if = "String::is_empty",
128 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
129 )]
130 pub first_name: String,
131 #[serde(
135 default,
136 skip_serializing_if = "String::is_empty",
137 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
138 )]
139 pub id: String,
140 #[serde(
144 default,
145 skip_serializing_if = "String::is_empty",
146 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
147 )]
148 pub last_name: String,
149 #[serde(
153 default,
154 skip_serializing_if = "String::is_empty",
155 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
156 )]
157 pub location_id: String,
158 #[serde(
162 default,
163 skip_serializing_if = "String::is_empty",
164 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
165 )]
166 pub manager_id: String,
167 #[serde(
171 default,
172 skip_serializing_if = "String::is_empty",
173 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
174 )]
175 pub phone: String,
176 #[serde(default, skip_serializing_if = "Role::is_noop")]
177 pub role: Role,
178}
179
180#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
181pub struct PatchUsersRequest {
182 #[serde(
186 default,
187 skip_serializing_if = "String::is_empty",
188 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
189 )]
190 pub department_id: String,
191 #[serde(
195 default,
196 skip_serializing_if = "String::is_empty",
197 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
198 )]
199 pub direct_manager_id: String,
200 #[serde(
204 default,
205 skip_serializing_if = "String::is_empty",
206 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
207 )]
208 pub location_id: String,
209 #[serde(default, skip_serializing_if = "Option::is_none")]
210 pub role: Option<Role>,
211}
212
213#[derive(Serialize, Default, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
214pub struct Page {
215 #[serde(
219 default,
220 skip_serializing_if = "String::is_empty",
221 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
222 )]
223 pub next: String,
224}
225
226#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
227pub struct CardHolder {
228 #[serde(
232 default,
233 skip_serializing_if = "String::is_empty",
234 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
235 )]
236 pub department_id: String,
237 #[serde(
241 default,
242 skip_serializing_if = "String::is_empty",
243 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
244 )]
245 pub department_name: String,
246 #[serde(
250 default,
251 skip_serializing_if = "String::is_empty",
252 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
253 )]
254 pub first_name: String,
255 #[serde(
259 default,
260 skip_serializing_if = "String::is_empty",
261 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
262 )]
263 pub last_name: String,
264 #[serde(
268 default,
269 skip_serializing_if = "String::is_empty",
270 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
271 )]
272 pub location_id: String,
273 #[serde(
277 default,
278 skip_serializing_if = "String::is_empty",
279 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
280 )]
281 pub location_name: String,
282}
283
284#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
285pub struct AccountingCategories {
286 #[serde(
290 default,
291 skip_serializing_if = "String::is_empty",
292 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
293 )]
294 pub category_id: String,
295 #[serde(
299 default,
300 skip_serializing_if = "String::is_empty",
301 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
302 )]
303 pub category_name: String,
304}
305
306#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
307pub enum Type {
308 #[serde(rename = "POLICY_VIOLATION_FROM_ADMIN")]
309 PolicyViolationFromAdmin,
310 #[serde(rename = "POLICY_VIOLATION_FROM_USER")]
311 PolicyViolationFromUser,
312 #[serde(rename = "")]
313 #[default]
314 Noop,
315 #[serde(other)]
316 FallthroughString,
317}
318
319impl std::fmt::Display for Type {
320 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
321 match self {
322 Type::PolicyViolationFromAdmin => "POLICY_VIOLATION_FROM_ADMIN",
323 Type::PolicyViolationFromUser => "POLICY_VIOLATION_FROM_USER",
324 Type::Noop => "",
325 Type::FallthroughString => "*",
326 }
327 .fmt(f)
328 }
329}
330
331impl Type {
332 pub fn is_noop(&self) -> bool {
333 matches!(self, Type::Noop)
334 }
335}
336
337#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
338pub struct PolicyViolations {
339 #[serde(
340 default,
341 skip_serializing_if = "Option::is_none",
342 deserialize_with = "crate::utils::date_time_format::deserialize"
343 )]
344 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
345 #[serde(
349 default,
350 skip_serializing_if = "String::is_empty",
351 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
352 )]
353 pub id: String,
354 #[serde(
358 default,
359 skip_serializing_if = "String::is_empty",
360 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
361 )]
362 pub memo: String,
363 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
364 pub type_: Option<Type>,
365}
366
367#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
368pub enum GetTransactionResponseDataDisputesType {
369 #[serde(rename = "DISPUTE_CANCELLED")]
370 DisputeCancelled,
371 #[serde(rename = "MERCHANT_ERROR")]
372 MerchantError,
373 #[serde(rename = "UNKNOWN")]
374 Unknown,
375 #[serde(rename = "UNRECOGNIZED_CHARGE")]
376 UnrecognizedCharge,
377 #[serde(rename = "")]
378 #[default]
379 Noop,
380 #[serde(other)]
381 FallthroughString,
382}
383
384impl std::fmt::Display for GetTransactionResponseDataDisputesType {
385 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
386 match self {
387 GetTransactionResponseDataDisputesType::DisputeCancelled => "DISPUTE_CANCELLED",
388 GetTransactionResponseDataDisputesType::MerchantError => "MERCHANT_ERROR",
389 GetTransactionResponseDataDisputesType::Unknown => "UNKNOWN",
390 GetTransactionResponseDataDisputesType::UnrecognizedCharge => "UNRECOGNIZED_CHARGE",
391 GetTransactionResponseDataDisputesType::Noop => "",
392 GetTransactionResponseDataDisputesType::FallthroughString => "*",
393 }
394 .fmt(f)
395 }
396}
397
398impl GetTransactionResponseDataDisputesType {
399 pub fn is_noop(&self) -> bool {
400 matches!(self, GetTransactionResponseDataDisputesType::Noop)
401 }
402}
403
404#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
405pub struct Disputes {
406 #[serde(
407 default,
408 skip_serializing_if = "Option::is_none",
409 deserialize_with = "crate::utils::date_time_format::deserialize"
410 )]
411 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
412 #[serde(
416 default,
417 skip_serializing_if = "String::is_empty",
418 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
419 )]
420 pub id: String,
421 #[serde(
425 default,
426 skip_serializing_if = "String::is_empty",
427 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
428 )]
429 pub memo: String,
430 #[serde(default, skip_serializing_if = "Option::is_none", rename = "type")]
431 pub type_: Option<GetTransactionResponseDataDisputesType>,
432}
433
434#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
436pub struct Data {
437 #[serde(
441 default,
442 skip_serializing_if = "Vec::is_empty",
443 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
444 )]
445 pub accounting_categories: Vec<AccountingCategories>,
446 #[serde(
450 default,
451 skip_serializing_if = "crate::utils::zero_f64",
452 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
453 )]
454 pub amount: f64,
455 pub card_holder: CardHolder,
456 #[serde(
460 default,
461 skip_serializing_if = "String::is_empty",
462 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
463 )]
464 pub card_id: String,
465 #[serde(
469 default,
470 skip_serializing_if = "Vec::is_empty",
471 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
472 )]
473 pub disputes: Vec<Disputes>,
474 #[serde(
478 default,
479 skip_serializing_if = "String::is_empty",
480 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
481 )]
482 pub id: String,
483 #[serde(
487 default,
488 skip_serializing_if = "String::is_empty",
489 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
490 )]
491 pub memo: String,
492 #[serde(
496 default,
497 skip_serializing_if = "String::is_empty",
498 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
499 )]
500 pub merchant_id: String,
501 #[serde(
505 default,
506 skip_serializing_if = "String::is_empty",
507 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
508 )]
509 pub merchant_name: String,
510 #[serde(
514 default,
515 skip_serializing_if = "Vec::is_empty",
516 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
517 )]
518 pub policy_violations: Vec<PolicyViolations>,
519 #[serde(
523 default,
524 skip_serializing_if = "Vec::is_empty",
525 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
526 )]
527 pub receipts: Vec<String>,
528 #[serde(
532 default,
533 skip_serializing_if = "crate::utils::zero_f64",
534 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
535 )]
536 pub sk_category_id: f64,
537 #[serde(
541 default,
542 skip_serializing_if = "String::is_empty",
543 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
544 )]
545 pub sk_category_name: String,
546 #[serde(
550 default,
551 skip_serializing_if = "String::is_empty",
552 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
553 )]
554 pub state: String,
555 #[serde(
556 default,
557 skip_serializing_if = "Option::is_none",
558 deserialize_with = "crate::utils::date_time_format::deserialize"
559 )]
560 pub user_transaction_time: Option<chrono::DateTime<chrono::Utc>>,
561}
562
563#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
564pub struct GetTransactionResponse {
565 #[serde(
566 default,
567 skip_serializing_if = "Vec::is_empty",
568 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
569 )]
570 pub data: Vec<Data>,
571 #[serde(default)]
572 pub page: Page,
573}
574
575#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
577pub struct Location {
578 #[serde(
582 default,
583 skip_serializing_if = "String::is_empty",
584 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
585 )]
586 pub id: String,
587 #[serde(
591 default,
592 skip_serializing_if = "String::is_empty",
593 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
594 )]
595 pub name: String,
596}
597
598#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
599pub struct GetLocationResponse {
600 #[serde(
601 default,
602 skip_serializing_if = "Vec::is_empty",
603 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
604 )]
605 pub data: Vec<Location>,
606 #[serde(default)]
607 pub page: Page,
608}
609
610#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
612pub struct PostLocationRequest {
613 #[serde(
617 default,
618 skip_serializing_if = "String::is_empty",
619 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
620 )]
621 pub name: String,
622}
623
624#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
626pub struct GetUsersResponse {
627 #[serde(
628 default,
629 skip_serializing_if = "Vec::is_empty",
630 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
631 )]
632 pub data: Vec<User>,
633 #[serde(default)]
634 pub page: Page,
635}
636
637#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
639pub struct Department {
640 #[serde(
644 default,
645 skip_serializing_if = "String::is_empty",
646 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
647 )]
648 pub id: String,
649 #[serde(
653 default,
654 skip_serializing_if = "String::is_empty",
655 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
656 )]
657 pub name: String,
658}
659
660#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
661pub struct GetDepartmentsResponse {
662 #[serde(
663 default,
664 skip_serializing_if = "Vec::is_empty",
665 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
666 )]
667 pub data: Vec<Department>,
668 #[serde(default)]
669 pub page: Page,
670}
671
672#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
673pub struct RecipientAddress {
674 #[serde(
678 default,
679 skip_serializing_if = "String::is_empty",
680 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
681 rename = "address1"
682 )]
683 pub address_1: String,
684 #[serde(
688 default,
689 skip_serializing_if = "String::is_empty",
690 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
691 )]
692 pub city: String,
693 #[serde(
697 default,
698 skip_serializing_if = "String::is_empty",
699 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
700 )]
701 pub country: String,
702 #[serde(
706 default,
707 skip_serializing_if = "String::is_empty",
708 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
709 )]
710 pub first_name: String,
711 #[serde(
715 default,
716 skip_serializing_if = "String::is_empty",
717 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
718 )]
719 pub last_name: String,
720 #[serde(
724 default,
725 skip_serializing_if = "String::is_empty",
726 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
727 )]
728 pub postal_code: String,
729 #[serde(
733 default,
734 skip_serializing_if = "String::is_empty",
735 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
736 )]
737 pub state: String,
738}
739
740#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
741pub struct Shipping {
742 #[serde(default, skip_serializing_if = "Option::is_none")]
743 pub recipient_address: Option<RecipientAddress>,
744}
745
746#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
748pub struct Fulfillment {
749 #[serde(default, skip_serializing_if = "Option::is_none")]
753 pub shipping: Option<Shipping>,
754}
755
756#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
760pub enum Interval {
761 #[serde(rename = "DAILY")]
762 Daily,
763 #[serde(rename = "MONTHLY")]
764 Monthly,
765 #[serde(rename = "TOTAL")]
766 Total,
767 #[serde(rename = "YEARLY")]
768 Yearly,
769 #[serde(rename = "")]
770 #[default]
771 Noop,
772 #[serde(other)]
773 FallthroughString,
774}
775
776impl std::fmt::Display for Interval {
777 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
778 match self {
779 Interval::Daily => "DAILY",
780 Interval::Monthly => "MONTHLY",
781 Interval::Total => "TOTAL",
782 Interval::Yearly => "YEARLY",
783 Interval::Noop => "",
784 Interval::FallthroughString => "*",
785 }
786 .fmt(f)
787 }
788}
789
790impl Interval {
791 pub fn is_noop(&self) -> bool {
792 matches!(self, Interval::Noop)
793 }
794}
795
796#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
798pub struct SpendingRestrictions {
799 #[serde(
803 default,
804 skip_serializing_if = "crate::utils::zero_f64",
805 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
806 )]
807 pub amount: f64,
808 #[serde(
812 default,
813 skip_serializing_if = "Vec::is_empty",
814 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
815 )]
816 pub blocked_categories: Vec<f64>,
817 #[serde(
821 default,
822 skip_serializing_if = "Vec::is_empty",
823 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
824 )]
825 pub categories: Vec<f64>,
826 #[serde(default, skip_serializing_if = "Interval::is_noop")]
830 pub interval: Interval,
831 #[serde(
835 default,
836 skip_serializing_if = "Option::is_none",
837 deserialize_with = "crate::utils::date_time_format::deserialize"
838 )]
839 pub lock_date: Option<chrono::DateTime<chrono::Utc>>,
840 #[serde(
844 default,
845 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
846 )]
847 pub suspended: bool,
848 #[serde(
852 default,
853 skip_serializing_if = "crate::utils::zero_f64",
854 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
855 )]
856 pub transaction_amount_limit: f64,
857}
858
859#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
861pub struct Card {
862 #[serde(
866 default,
867 skip_serializing_if = "String::is_empty",
868 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
869 )]
870 pub card_program_id: String,
871 #[serde(
875 default,
876 skip_serializing_if = "String::is_empty",
877 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
878 )]
879 pub cardholder_id: String,
880 #[serde(
884 default,
885 skip_serializing_if = "String::is_empty",
886 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
887 )]
888 pub cardholder_name: String,
889 #[serde(
893 default,
894 skip_serializing_if = "String::is_empty",
895 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
896 )]
897 pub display_name: String,
898 #[serde(default, skip_serializing_if = "Option::is_none")]
902 pub fulfillment: Option<Fulfillment>,
903 #[serde(
907 default,
908 skip_serializing_if = "String::is_empty",
909 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
910 )]
911 pub id: String,
912 #[serde(
916 default,
917 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
918 )]
919 pub is_physical: bool,
920 #[serde(
924 default,
925 skip_serializing_if = "String::is_empty",
926 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
927 )]
928 pub last_four: String,
929 #[serde(default, skip_serializing_if = "Option::is_none")]
933 pub spending_restrictions: Option<SpendingRestrictions>,
934}
935
936#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
937pub struct GetCardsResponse {
938 #[serde(
939 default,
940 skip_serializing_if = "Vec::is_empty",
941 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
942 )]
943 pub cards: Vec<Card>,
944 #[serde(default)]
945 pub page: Page,
946}
947
948#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
949pub struct PatchResourcesCardsCardRequest {
950 #[serde(
954 default,
955 skip_serializing_if = "String::is_empty",
956 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
957 )]
958 pub card_program_id: String,
959 #[serde(
963 default,
964 skip_serializing_if = "String::is_empty",
965 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
966 )]
967 pub display_name: String,
968 #[serde(default, skip_serializing_if = "Option::is_none")]
969 pub has_notifications_enabled: Option<bool>,
970 #[serde(default, skip_serializing_if = "Option::is_none")]
974 pub spending_restrictions: Option<SpendingRestrictions>,
975}
976
977#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
978pub struct GetCustomProviderResponse {
979 #[serde(
983 default,
984 skip_serializing_if = "String::is_empty",
985 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
986 )]
987 pub custom_id_provider: String,
988}
989
990#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
991pub struct PostcustomProviderResponse {
992 #[serde(
996 default,
997 skip_serializing_if = "String::is_empty",
998 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
999 )]
1000 pub provider_id: String,
1001}
1002
1003#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1004pub struct BillingAddress {
1005 #[serde(
1009 default,
1010 skip_serializing_if = "String::is_empty",
1011 deserialize_with = "crate::utils::deserialize_null_string::deserialize",
1012 rename = "address1"
1013 )]
1014 pub address_1: String,
1015 #[serde(
1019 default,
1020 skip_serializing_if = "String::is_empty",
1021 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1022 )]
1023 pub city: String,
1024 #[serde(
1028 default,
1029 skip_serializing_if = "String::is_empty",
1030 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1031 )]
1032 pub country: String,
1033 #[serde(
1037 default,
1038 skip_serializing_if = "String::is_empty",
1039 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1040 )]
1041 pub postal_code: String,
1042 #[serde(
1046 default,
1047 skip_serializing_if = "String::is_empty",
1048 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1049 )]
1050 pub state: String,
1051}
1052
1053#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1055pub struct Business {
1056 #[serde(
1057 default,
1058 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1059 )]
1060 pub active: bool,
1061 pub billing_address: BillingAddress,
1062 #[serde(
1066 default,
1067 skip_serializing_if = "crate::utils::zero_f64",
1068 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
1069 )]
1070 pub business_memo_required_threshold: f64,
1071 #[serde(
1075 default,
1076 skip_serializing_if = "String::is_empty",
1077 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1078 )]
1079 pub business_name_legal: String,
1080 #[serde(
1084 default,
1085 skip_serializing_if = "String::is_empty",
1086 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1087 )]
1088 pub business_name_on_card: String,
1089 #[serde(
1093 default,
1094 skip_serializing_if = "crate::utils::zero_f64",
1095 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
1096 )]
1097 pub business_receipt_required_threshold: f64,
1098 #[serde(
1102 default,
1103 skip_serializing_if = "String::is_empty",
1104 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1105 )]
1106 pub created_time: String,
1107 #[serde(
1108 default,
1109 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1110 )]
1111 pub enforce_sso: bool,
1112 #[serde(
1116 default,
1117 skip_serializing_if = "String::is_empty",
1118 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1119 )]
1120 pub id: String,
1121 #[serde(
1125 default,
1126 skip_serializing_if = "crate::utils::zero_f64",
1127 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
1128 )]
1129 pub initial_approved_limit: f64,
1130 #[serde(
1131 default,
1132 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1133 )]
1134 pub is_integrated_with_slack: bool,
1135 #[serde(
1136 default,
1137 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1138 )]
1139 pub is_reimbursements_enabled: bool,
1140 #[serde(
1141 default,
1142 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1143 )]
1144 pub limit_locked: bool,
1145 #[serde(
1149 default,
1150 skip_serializing_if = "String::is_empty",
1151 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1152 )]
1153 pub phone: String,
1154 #[serde(
1158 default,
1159 skip_serializing_if = "String::is_empty",
1160 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1161 )]
1162 pub website: String,
1163}
1164
1165#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1166pub struct PostResourcesCardPhysicalRequest {
1167 #[serde(
1171 default,
1172 skip_serializing_if = "String::is_empty",
1173 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1174 )]
1175 pub card_program_id: String,
1176 #[serde(
1180 default,
1181 skip_serializing_if = "String::is_empty",
1182 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1183 )]
1184 pub display_name: String,
1185 #[serde(default, skip_serializing_if = "Option::is_none")]
1189 pub fulfillment: Option<Fulfillment>,
1190 #[serde(
1194 default,
1195 skip_serializing_if = "String::is_empty",
1196 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1197 )]
1198 pub idempotency_key: String,
1199 #[serde(default, skip_serializing_if = "Option::is_none")]
1203 pub spending_restrictions: Option<SpendingRestrictions>,
1204 #[serde(
1208 default,
1209 skip_serializing_if = "String::is_empty",
1210 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1211 )]
1212 pub user_id: String,
1213}
1214
1215#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1216pub struct PostResourcesCardVirtualRequest {
1217 #[serde(
1221 default,
1222 skip_serializing_if = "String::is_empty",
1223 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1224 )]
1225 pub card_program_id: String,
1226 #[serde(
1230 default,
1231 skip_serializing_if = "String::is_empty",
1232 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1233 )]
1234 pub display_name: String,
1235 #[serde(
1239 default,
1240 skip_serializing_if = "String::is_empty",
1241 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1242 )]
1243 pub idempotency_key: String,
1244 #[serde(default, skip_serializing_if = "Option::is_none")]
1248 pub spending_restrictions: Option<SpendingRestrictions>,
1249 #[serde(
1253 default,
1254 skip_serializing_if = "String::is_empty",
1255 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1256 )]
1257 pub user_id: String,
1258}
1259
1260#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
1261pub enum TokenType {
1262 #[serde(rename = "Bearer")]
1263 Bearer,
1264 #[serde(rename = "")]
1265 #[default]
1266 Noop,
1267 #[serde(other)]
1268 FallthroughString,
1269}
1270
1271impl std::fmt::Display for TokenType {
1272 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1273 match self {
1274 TokenType::Bearer => "Bearer",
1275 TokenType::Noop => "",
1276 TokenType::FallthroughString => "*",
1277 }
1278 .fmt(f)
1279 }
1280}
1281
1282impl TokenType {
1283 pub fn is_noop(&self) -> bool {
1284 matches!(self, TokenType::Noop)
1285 }
1286}
1287
1288#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1290pub struct OAuth2Token {
1291 #[serde(
1295 default,
1296 skip_serializing_if = "String::is_empty",
1297 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1298 )]
1299 pub access_token: String,
1300 #[serde(
1304 default,
1305 skip_serializing_if = "crate::utils::zero_i64",
1306 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1307 )]
1308 pub expires_in: i64,
1309 #[serde(
1313 default,
1314 skip_serializing_if = "String::is_empty",
1315 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1316 )]
1317 pub refresh_token: String,
1318 #[serde(
1322 default,
1323 skip_serializing_if = "crate::utils::zero_i64",
1324 deserialize_with = "crate::utils::deserialize_null_i64::deserialize"
1325 )]
1326 pub refresh_token_expires_in: i64,
1327 #[serde(
1331 default,
1332 skip_serializing_if = "String::is_empty",
1333 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1334 )]
1335 pub scope: String,
1336 #[serde(default, skip_serializing_if = "TokenType::is_noop")]
1337 pub token_type: TokenType,
1338}
1339
1340#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1342pub struct BusinessCurrentStatus {
1343 #[serde(
1347 default,
1348 skip_serializing_if = "crate::utils::zero_f64",
1349 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
1350 )]
1351 pub balance_including_pending: f64,
1352 #[serde(
1356 default,
1357 skip_serializing_if = "crate::utils::zero_f64",
1358 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
1359 )]
1360 pub max_balance: f64,
1361 #[serde(
1365 default,
1366 skip_serializing_if = "Option::is_none",
1367 deserialize_with = "crate::utils::date_format::deserialize"
1368 )]
1369 pub next_billing_date: Option<chrono::NaiveDate>,
1370 #[serde(
1374 default,
1375 skip_serializing_if = "Option::is_none",
1376 deserialize_with = "crate::utils::date_format::deserialize"
1377 )]
1378 pub prev_billing_date: Option<chrono::NaiveDate>,
1379 #[serde(
1383 default,
1384 skip_serializing_if = "crate::utils::zero_f64",
1385 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
1386 )]
1387 pub statement_balance: f64,
1388}
1389
1390#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1391pub struct PostResourcesCardsCardSuspensionRequest {
1392 #[serde(
1396 default,
1397 skip_serializing_if = "String::is_empty",
1398 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1399 )]
1400 pub idempotency_key: String,
1401}
1402
1403#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1404pub struct GetEntityTypeCustomRampResponse {
1405 #[serde(
1409 default,
1410 skip_serializing_if = "String::is_empty",
1411 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1412 )]
1413 pub ramp_id: String,
1414}
1415
1416#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1417pub struct GetEntityTypeRampCustomResponse {
1418 #[serde(
1422 default,
1423 skip_serializing_if = "String::is_empty",
1424 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1425 )]
1426 pub custom_id: String,
1427}
1428
1429#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1430pub struct GetResourcesCardsDeferredResponseData {
1431 #[serde(
1435 default,
1436 skip_serializing_if = "String::is_empty",
1437 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1438 )]
1439 pub card_id: String,
1440 #[serde(
1444 default,
1445 skip_serializing_if = "String::is_empty",
1446 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1447 )]
1448 pub error: String,
1449 #[serde(
1453 default,
1454 skip_serializing_if = "String::is_empty",
1455 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1456 )]
1457 pub id: String,
1458 #[serde(
1462 default,
1463 skip_serializing_if = "String::is_empty",
1464 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1465 )]
1466 pub misc: String,
1467}
1468
1469#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
1470pub enum Status {
1471 #[serde(rename = "ERROR")]
1472 Error,
1473 #[serde(rename = "IN_PROGRESS")]
1474 InProgress,
1475 #[serde(rename = "STARTED")]
1476 Started,
1477 #[serde(rename = "SUCCESS")]
1478 Success,
1479 #[serde(rename = "")]
1480 #[default]
1481 Noop,
1482 #[serde(other)]
1483 FallthroughString,
1484}
1485
1486impl std::fmt::Display for Status {
1487 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1488 match self {
1489 Status::Error => "ERROR",
1490 Status::InProgress => "IN_PROGRESS",
1491 Status::Started => "STARTED",
1492 Status::Success => "SUCCESS",
1493 Status::Noop => "",
1494 Status::FallthroughString => "*",
1495 }
1496 .fmt(f)
1497 }
1498}
1499
1500impl Status {
1501 pub fn is_noop(&self) -> bool {
1502 matches!(self, Status::Noop)
1503 }
1504}
1505
1506#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1507pub struct GetResourcesCardsDeferredResponse {
1508 #[serde(default, skip_serializing_if = "Option::is_none")]
1509 pub data: Option<GetResourcesCardsDeferredResponseData>,
1510 #[serde(
1514 default,
1515 skip_serializing_if = "String::is_empty",
1516 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1517 )]
1518 pub id: String,
1519 #[serde(default, skip_serializing_if = "Option::is_none")]
1520 pub status: Option<Status>,
1521}
1522
1523#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema, Default)]
1524pub enum Icon {
1525 #[serde(rename = "AdvertisingIcon")]
1526 AdvertisingIcon,
1527 #[serde(rename = "CardIcon")]
1528 CardIcon,
1529 #[serde(rename = "EducationStipendIcon")]
1530 EducationStipendIcon,
1531 #[serde(rename = "LunchOrderingIcon")]
1532 LunchOrderingIcon,
1533 #[serde(rename = "OnboardingIcon")]
1534 OnboardingIcon,
1535 #[serde(rename = "PerDiemCardIcon")]
1536 PerDiemCardIcon,
1537 #[serde(rename = "SaasSubscriptionIcon")]
1538 SaasSubscriptionIcon,
1539 #[serde(rename = "SoftwareTrialIcon")]
1540 SoftwareTrialIcon,
1541 #[serde(rename = "TravelExpensesIcon")]
1542 TravelExpensesIcon,
1543 #[serde(rename = "WellnessIcon")]
1544 WellnessIcon,
1545 #[serde(rename = "")]
1546 #[default]
1547 Noop,
1548 #[serde(other)]
1549 FallthroughString,
1550}
1551
1552impl std::fmt::Display for Icon {
1553 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1554 match self {
1555 Icon::AdvertisingIcon => "AdvertisingIcon",
1556 Icon::CardIcon => "CardIcon",
1557 Icon::EducationStipendIcon => "EducationStipendIcon",
1558 Icon::LunchOrderingIcon => "LunchOrderingIcon",
1559 Icon::OnboardingIcon => "OnboardingIcon",
1560 Icon::PerDiemCardIcon => "PerDiemCardIcon",
1561 Icon::SaasSubscriptionIcon => "SaasSubscriptionIcon",
1562 Icon::SoftwareTrialIcon => "SoftwareTrialIcon",
1563 Icon::TravelExpensesIcon => "TravelExpensesIcon",
1564 Icon::WellnessIcon => "WellnessIcon",
1565 Icon::Noop => "",
1566 Icon::FallthroughString => "*",
1567 }
1568 .fmt(f)
1569 }
1570}
1571
1572impl Icon {
1573 pub fn is_noop(&self) -> bool {
1574 matches!(self, Icon::Noop)
1575 }
1576}
1577
1578#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1580pub struct CardProgram {
1581 #[serde(
1585 default,
1586 skip_serializing_if = "String::is_empty",
1587 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1588 )]
1589 pub description: String,
1590 #[serde(
1594 default,
1595 skip_serializing_if = "String::is_empty",
1596 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1597 )]
1598 pub display_name: String,
1599 #[serde(default, skip_serializing_if = "Option::is_none")]
1603 pub icon: Option<Icon>,
1604 #[serde(
1608 default,
1609 skip_serializing_if = "String::is_empty",
1610 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1611 )]
1612 pub id: String,
1613 #[serde(
1617 default,
1618 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1619 )]
1620 pub is_default: bool,
1621 #[serde(
1625 default,
1626 deserialize_with = "crate::utils::deserialize_null_boolean::deserialize"
1627 )]
1628 pub is_physical: bool,
1629 #[serde(default, skip_serializing_if = "Option::is_none")]
1633 pub spending_restrictions: Option<SpendingRestrictions>,
1634}
1635
1636#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1637pub struct GetCardProgramsResponse {
1638 #[serde(
1639 default,
1640 skip_serializing_if = "Vec::is_empty",
1641 deserialize_with = "crate::utils::deserialize_null_vector::deserialize",
1642 rename = "card-programs"
1643 )]
1644 pub card_programs: Vec<CardProgram>,
1645 #[serde(default)]
1646 pub page: Page,
1647}
1648
1649#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1650pub struct PostResourcesCardProgramRequest {
1651 #[serde(
1655 default,
1656 skip_serializing_if = "String::is_empty",
1657 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1658 )]
1659 pub description: String,
1660 #[serde(
1664 default,
1665 skip_serializing_if = "String::is_empty",
1666 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1667 )]
1668 pub display_name: String,
1669 #[serde(default, skip_serializing_if = "Icon::is_noop")]
1670 pub icon: Icon,
1671 #[serde(default, skip_serializing_if = "Option::is_none")]
1672 pub is_default: Option<bool>,
1673 #[serde(default, skip_serializing_if = "Option::is_none")]
1674 pub is_physical: Option<bool>,
1675 pub spending_restrictions: SpendingRestrictions,
1679}
1680
1681#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1682pub struct PostUsersDeferredRequest {
1683 #[serde(
1687 default,
1688 skip_serializing_if = "String::is_empty",
1689 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1690 )]
1691 pub department_id: String,
1692 #[serde(
1696 default,
1697 skip_serializing_if = "String::is_empty",
1698 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1699 )]
1700 pub direct_manager_id: String,
1701 #[serde(
1705 default,
1706 skip_serializing_if = "String::is_empty",
1707 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1708 )]
1709 pub email: String,
1710 #[serde(
1714 default,
1715 skip_serializing_if = "String::is_empty",
1716 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1717 )]
1718 pub first_name: String,
1719 #[serde(
1723 default,
1724 skip_serializing_if = "String::is_empty",
1725 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1726 )]
1727 pub last_name: String,
1728 #[serde(
1732 default,
1733 skip_serializing_if = "String::is_empty",
1734 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1735 )]
1736 pub location_id: String,
1737 #[serde(
1741 default,
1742 skip_serializing_if = "String::is_empty",
1743 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1744 )]
1745 pub phone: String,
1746 #[serde(default, skip_serializing_if = "Role::is_noop")]
1747 pub role: Role,
1748}
1749
1750#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1751pub struct GetUsersDeferredStatusResponseData {
1752 #[serde(
1756 default,
1757 skip_serializing_if = "String::is_empty",
1758 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1759 )]
1760 pub error: String,
1761 #[serde(
1765 default,
1766 skip_serializing_if = "String::is_empty",
1767 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1768 )]
1769 pub id: String,
1770 #[serde(
1774 default,
1775 skip_serializing_if = "String::is_empty",
1776 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1777 )]
1778 pub misc: String,
1779 #[serde(
1783 default,
1784 skip_serializing_if = "String::is_empty",
1785 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1786 )]
1787 pub user_id: String,
1788}
1789
1790#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1792pub struct GetUsersDeferredStatusResponse {
1793 #[serde(default, skip_serializing_if = "Option::is_none")]
1797 pub data: Option<GetUsersDeferredStatusResponseData>,
1798 #[serde(
1802 default,
1803 skip_serializing_if = "String::is_empty",
1804 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1805 )]
1806 pub id: String,
1807 #[serde(
1811 default,
1812 skip_serializing_if = "String::is_empty",
1813 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1814 )]
1815 pub status: String,
1816}
1817
1818#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1820pub struct GetUsersDeferredStatusResponseDataType {
1821 #[serde(default, skip_serializing_if = "Option::is_none")]
1825 pub error: Option<Error>,
1826}
1827
1828#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1829pub struct Receipt {
1830 #[serde(
1831 default,
1832 skip_serializing_if = "Option::is_none",
1833 deserialize_with = "crate::utils::date_time_format::deserialize"
1834 )]
1835 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1836 #[serde(
1837 default,
1838 skip_serializing_if = "String::is_empty",
1839 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1840 )]
1841 pub id: String,
1842 #[serde(
1843 default,
1844 skip_serializing_if = "String::is_empty",
1845 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1846 )]
1847 pub receipt_url: String,
1848 #[serde(
1849 default,
1850 skip_serializing_if = "String::is_empty",
1851 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1852 )]
1853 pub transaction_id: String,
1854 #[serde(
1855 default,
1856 skip_serializing_if = "String::is_empty",
1857 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1858 )]
1859 pub user_id: String,
1860}
1861
1862#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1863pub struct GetReceiptsResponse {
1864 #[serde(
1865 default,
1866 skip_serializing_if = "Vec::is_empty",
1867 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
1868 )]
1869 pub data: Vec<Receipt>,
1870 #[serde(default)]
1871 pub page: Page,
1872}
1873
1874#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1875pub struct Reimbursement {
1876 #[serde(
1877 default,
1878 skip_serializing_if = "crate::utils::zero_f64",
1879 deserialize_with = "crate::utils::deserialize_null_f64::deserialize"
1880 )]
1881 pub amount: f64,
1882 #[serde(
1883 default,
1884 skip_serializing_if = "Option::is_none",
1885 deserialize_with = "crate::utils::date_time_format::deserialize"
1886 )]
1887 pub created_at: Option<chrono::DateTime<chrono::Utc>>,
1888 #[serde(
1889 default,
1890 skip_serializing_if = "String::is_empty",
1891 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1892 )]
1893 pub currency: String,
1894 #[serde(
1895 default,
1896 skip_serializing_if = "String::is_empty",
1897 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1898 )]
1899 pub id: String,
1900 #[serde(
1901 default,
1902 skip_serializing_if = "String::is_empty",
1903 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1904 )]
1905 pub merchant: String,
1906 #[serde(
1907 default,
1908 skip_serializing_if = "Vec::is_empty",
1909 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
1910 )]
1911 pub receipts: Vec<String>,
1912 #[serde(
1913 default,
1914 skip_serializing_if = "Option::is_none",
1915 deserialize_with = "crate::utils::date_format::deserialize"
1916 )]
1917 pub transaction_date: Option<chrono::NaiveDate>,
1918 #[serde(
1919 default,
1920 skip_serializing_if = "String::is_empty",
1921 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1922 )]
1923 pub user_id: String,
1924}
1925
1926#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1927pub struct GetReimbursementsResponse {
1928 #[serde(
1929 default,
1930 skip_serializing_if = "Vec::is_empty",
1931 deserialize_with = "crate::utils::deserialize_null_vector::deserialize"
1932 )]
1933 pub data: Vec<Reimbursement>,
1934 #[serde(default)]
1935 pub page: Page,
1936}
1937
1938#[derive(Serialize, Deserialize, PartialEq, Debug, Clone, JsonSchema)]
1939pub struct PostCustomProviderEntityTypeLinkRequest {
1940 #[serde(
1944 default,
1945 skip_serializing_if = "String::is_empty",
1946 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1947 )]
1948 pub custom_id: String,
1949 #[serde(
1953 default,
1954 skip_serializing_if = "String::is_empty",
1955 deserialize_with = "crate::utils::deserialize_null_string::deserialize"
1956 )]
1957 pub ramp_id: String,
1958}