1use serde::{Deserialize, Serialize};
22use strum::{AsRefStr, Display, EnumIter, EnumString, FromRepr};
23
24#[derive(
26 Copy,
27 Clone,
28 Debug,
29 Default,
30 Display,
31 PartialEq,
32 Eq,
33 Hash,
34 AsRefStr,
35 EnumIter,
36 EnumString,
37 Serialize,
38 Deserialize,
39)]
40#[serde(rename_all = "lowercase")]
41#[strum(ascii_case_insensitive, serialize_all = "lowercase")]
42#[cfg_attr(
43 feature = "python",
44 pyo3::pyclass(
45 eq,
46 eq_int,
47 module = "nautilus_trader._libnautilus.kalshi",
48 from_py_object,
49 rename_all = "SCREAMING_SNAKE_CASE",
50 )
51)]
52#[cfg_attr(
53 feature = "python",
54 pyo3_stub_gen::derive::gen_stub_pyclass_enum(module = "nautilus_trader.adapters.kalshi")
55)]
56pub enum KalshiEnvironment {
57 #[default]
59 Production,
60 Demo,
62}
63
64impl KalshiEnvironment {
65 #[must_use]
67 pub const fn is_demo(self) -> bool {
68 matches!(self, Self::Demo)
69 }
70}
71
72#[derive(
74 Debug,
75 Clone,
76 Copy,
77 PartialEq,
78 Eq,
79 Hash,
80 Display,
81 AsRefStr,
82 EnumIter,
83 EnumString,
84 Serialize,
85 Deserialize,
86)]
87#[serde(rename_all = "snake_case")]
88#[strum(serialize_all = "snake_case")]
89pub enum ExitTriggerKind {
90 Bracket,
91}
92
93#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter, FromRepr, Serialize, Deserialize)]
95#[repr(u32)]
96#[serde(try_from = "u32", into = "u32")]
97pub enum CandlestickInterval {
98 Minute = 1,
99 Hour = 60,
100 Day = 1440,
101}
102
103impl From<CandlestickInterval> for u32 {
104 fn from(value: CandlestickInterval) -> Self {
105 value as Self
106 }
107}
108
109impl TryFrom<u32> for CandlestickInterval {
110 type Error = strum::ParseError;
111
112 fn try_from(value: u32) -> Result<Self, Self::Error> {
113 Self::from_repr(value).ok_or(strum::ParseError::VariantNotFound)
114 }
115}
116
117#[derive(
119 Debug,
120 Clone,
121 Copy,
122 PartialEq,
123 Eq,
124 Hash,
125 Display,
126 AsRefStr,
127 EnumIter,
128 EnumString,
129 Serialize,
130 Deserialize,
131)]
132#[serde(rename_all = "snake_case")]
133#[strum(serialize_all = "snake_case")]
134pub enum EventStatusFilter {
135 Unopened,
136 Open,
137 Closed,
138 Settled,
139}
140
141#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter, FromRepr, Serialize, Deserialize)]
143#[repr(u32)]
144#[serde(try_from = "u32", into = "u32")]
145pub enum ForecastInterval {
146 FiveSeconds = 0,
147 Minute = 1,
148 Hour = 60,
149 Day = 1440,
150}
151
152impl From<ForecastInterval> for u32 {
153 fn from(value: ForecastInterval) -> Self {
154 value as Self
155 }
156}
157
158impl TryFrom<u32> for ForecastInterval {
159 type Error = strum::ParseError;
160
161 fn try_from(value: u32) -> Result<Self, Self::Error> {
162 Self::from_repr(value).ok_or(strum::ParseError::VariantNotFound)
163 }
164}
165
166#[derive(
168 Debug,
169 Clone,
170 Copy,
171 PartialEq,
172 Eq,
173 Hash,
174 Display,
175 AsRefStr,
176 EnumIter,
177 EnumString,
178 Serialize,
179 Deserialize,
180)]
181#[serde(rename_all = "snake_case")]
182#[strum(serialize_all = "snake_case")]
183pub enum MultivariateCollectionStatus {
184 Unopened,
185 Open,
186 Closed,
187}
188
189#[derive(
191 Debug,
192 Clone,
193 Copy,
194 PartialEq,
195 Eq,
196 Hash,
197 Display,
198 AsRefStr,
199 EnumIter,
200 EnumString,
201 Serialize,
202 Deserialize,
203)]
204#[serde(rename_all = "snake_case")]
205#[strum(serialize_all = "snake_case")]
206pub enum IncentiveStatusFilter {
207 All,
208 Active,
209 Upcoming,
210 Closed,
211 PaidOut,
212}
213
214#[derive(
216 Debug,
217 Clone,
218 Copy,
219 PartialEq,
220 Eq,
221 Hash,
222 Display,
223 AsRefStr,
224 EnumIter,
225 EnumString,
226 Serialize,
227 Deserialize,
228)]
229#[serde(rename_all = "snake_case")]
230#[strum(serialize_all = "snake_case")]
231pub enum IncentiveTypeFilter {
232 All,
233 Liquidity,
234 Volume,
235 MarginMakerVolume,
236 MarginTakerVolume,
237}
238
239#[derive(
241 Debug,
242 Clone,
243 Copy,
244 PartialEq,
245 Eq,
246 Hash,
247 Display,
248 AsRefStr,
249 EnumIter,
250 EnumString,
251 Serialize,
252 Deserialize,
253)]
254#[serde(rename_all = "snake_case")]
255#[strum(serialize_all = "snake_case")]
256pub enum PositionSettlementStatus {
257 Unsettled,
258 Settled,
259 All,
260}
261
262#[derive(
264 Debug,
265 Clone,
266 Copy,
267 PartialEq,
268 Eq,
269 Hash,
270 Display,
271 AsRefStr,
272 EnumIter,
273 EnumString,
274 Serialize,
275 Deserialize,
276)]
277#[serde(rename_all = "snake_case")]
278#[strum(serialize_all = "snake_case")]
279pub enum MarketStatusFilter {
280 Unopened,
281 Open,
282 Paused,
283 Closed,
284 Settled,
285}
286
287#[derive(
289 Debug,
290 Clone,
291 Copy,
292 PartialEq,
293 Eq,
294 Hash,
295 Display,
296 AsRefStr,
297 EnumIter,
298 EnumString,
299 Serialize,
300 Deserialize,
301)]
302#[serde(rename_all = "snake_case")]
303#[strum(serialize_all = "snake_case")]
304pub enum MveFilter {
305 Only,
306 Exclude,
307}
308
309#[derive(
311 Debug,
312 Clone,
313 Copy,
314 PartialEq,
315 Eq,
316 Hash,
317 Display,
318 AsRefStr,
319 EnumIter,
320 EnumString,
321 Serialize,
322 Deserialize,
323)]
324#[serde(rename_all = "snake_case")]
325#[strum(serialize_all = "snake_case")]
326pub enum MveHistoricalFilter {
327 Exclude,
328}
329
330#[derive(
332 Debug,
333 Clone,
334 Copy,
335 PartialEq,
336 Eq,
337 Hash,
338 Display,
339 AsRefStr,
340 EnumIter,
341 EnumString,
342 Serialize,
343 Deserialize,
344)]
345#[serde(rename_all = "snake_case")]
346#[strum(serialize_all = "snake_case")]
347pub enum ExitSlippageUnit {
348 Bps,
349 Cents,
350}
351
352#[derive(
354 Debug,
355 Clone,
356 Copy,
357 PartialEq,
358 Eq,
359 Hash,
360 Display,
361 AsRefStr,
362 EnumIter,
363 EnumString,
364 Serialize,
365 Deserialize,
366)]
367#[serde(rename_all = "snake_case")]
368#[strum(serialize_all = "snake_case")]
369pub enum ExitTriggerStatus {
370 PendingOnEntry,
371 Active,
372 Filled,
373 Canceled,
374 Failed,
375 Unknown,
376}
377
378#[derive(
380 Debug,
381 Clone,
382 Copy,
383 PartialEq,
384 Eq,
385 Hash,
386 Display,
387 AsRefStr,
388 EnumIter,
389 EnumString,
390 Serialize,
391 Deserialize,
392)]
393#[serde(rename_all = "snake_case")]
394#[strum(serialize_all = "snake_case")]
395pub enum ExitTriggerLeg {
396 StopLoss,
397 TakeProfit,
398}
399
400#[derive(
402 Debug,
403 Clone,
404 PartialEq,
405 Eq,
406 Hash,
407 Display,
408 AsRefStr,
409 EnumIter,
410 EnumString,
411 Serialize,
412 Deserialize,
413)]
414#[serde(rename_all = "snake_case")]
415#[strum(serialize_all = "snake_case")]
416pub enum FeeType {
417 Quadratic,
418 QuadraticWithMakerFees,
419 QuadraticWithComboMakerFees,
420 Flat,
421 MarginMarketMakerProgramFees,
422 #[serde(untagged)]
423 #[strum(default, transparent)]
424 Other(String),
425}
426
427#[derive(
429 Debug,
430 Clone,
431 PartialEq,
432 Eq,
433 Hash,
434 Display,
435 AsRefStr,
436 EnumIter,
437 EnumString,
438 Serialize,
439 Deserialize,
440)]
441#[serde(rename_all = "snake_case")]
442#[strum(serialize_all = "snake_case")]
443pub enum ExchangeInstance {
444 EventContract,
445 Margined,
446 #[serde(untagged)]
447 #[strum(default, transparent)]
448 Other(String),
449}
450
451#[derive(
453 Debug,
454 Clone,
455 Copy,
456 PartialEq,
457 Eq,
458 Hash,
459 Display,
460 AsRefStr,
461 EnumIter,
462 EnumString,
463 Serialize,
464 Deserialize,
465)]
466#[serde(rename_all = "snake_case")]
467#[strum(serialize_all = "snake_case")]
468pub enum UserFilter {
469 #[serde(rename = "")]
470 #[strum(serialize = "")]
471 All,
472 #[serde(rename = "self")]
473 #[strum(serialize = "self")]
474 SelfUser,
475}
476
477#[derive(
479 Debug,
480 Clone,
481 Copy,
482 PartialEq,
483 Eq,
484 Hash,
485 Display,
486 AsRefStr,
487 EnumIter,
488 EnumString,
489 Serialize,
490 Deserialize,
491)]
492#[serde(rename_all = "snake_case")]
493#[strum(serialize_all = "snake_case")]
494pub enum ApiKeyScope {
495 Read,
496 Write,
497 #[serde(rename = "read::block_trade_accept")]
498 #[strum(serialize = "read::block_trade_accept")]
499 ReadBlockTradeAccept,
500 #[serde(rename = "read::portfolio_balance")]
501 #[strum(serialize = "read::portfolio_balance")]
502 ReadPortfolioBalance,
503 #[serde(rename = "write::trade")]
504 #[strum(serialize = "write::trade")]
505 WriteTrade,
506 #[serde(rename = "write::transfer")]
507 #[strum(serialize = "write::transfer")]
508 WriteTransfer,
509 #[serde(rename = "write::fcm_risk")]
510 #[strum(serialize = "write::fcm_risk")]
511 WriteFcmRisk,
512 #[serde(rename = "write::block_trade_accept")]
513 #[strum(serialize = "write::block_trade_accept")]
514 WriteBlockTradeAccept,
515}
516
517#[derive(
519 Debug,
520 Clone,
521 Copy,
522 PartialEq,
523 Eq,
524 Hash,
525 Display,
526 AsRefStr,
527 EnumIter,
528 EnumString,
529 Serialize,
530 Deserialize,
531)]
532#[serde(rename_all = "snake_case")]
533#[strum(serialize_all = "snake_case")]
534pub enum ApiKeyType {
535 Rsa,
536 Ed25519,
537}
538
539#[derive(
541 Debug,
542 Clone,
543 Copy,
544 PartialEq,
545 Eq,
546 Hash,
547 Display,
548 AsRefStr,
549 EnumIter,
550 EnumString,
551 Serialize,
552 Deserialize,
553)]
554#[serde(rename_all = "snake_case")]
555#[strum(serialize_all = "snake_case")]
556pub enum MarketIndexStatus {
557 Open,
558 Closed,
559 Stale,
560}
561
562#[derive(
564 Debug,
565 Clone,
566 Copy,
567 PartialEq,
568 Eq,
569 Hash,
570 Display,
571 AsRefStr,
572 EnumIter,
573 EnumString,
574 Serialize,
575 Deserialize,
576)]
577#[serde(rename_all = "snake_case")]
578#[strum(serialize_all = "snake_case")]
579pub enum CreditStatus {
580 Unknown,
581 Pending,
582 Failed,
583 Applied,
584}
585
586#[derive(
588 Debug,
589 Clone,
590 PartialEq,
591 Eq,
592 Hash,
593 Display,
594 AsRefStr,
595 EnumIter,
596 EnumString,
597 Serialize,
598 Deserialize,
599)]
600#[serde(rename_all = "snake_case")]
601#[strum(serialize_all = "snake_case")]
602pub enum MarketResult {
603 Yes,
604 No,
605 Scalar,
606 #[serde(rename = "")]
607 #[strum(serialize = "")]
608 Unsettled,
609 #[serde(untagged)]
610 #[strum(default, transparent)]
611 Other(String),
612}
613
614#[derive(
616 Debug,
617 Clone,
618 Copy,
619 PartialEq,
620 Eq,
621 Hash,
622 Display,
623 AsRefStr,
624 EnumIter,
625 EnumString,
626 Serialize,
627 Deserialize,
628)]
629#[serde(rename_all = "snake_case")]
630#[strum(serialize_all = "snake_case")]
631pub enum PaymentStatus {
632 Pending,
633 Applied,
634 Failed,
635 Returned,
636}
637
638#[derive(
640 Debug,
641 Clone,
642 Copy,
643 PartialEq,
644 Eq,
645 Hash,
646 Display,
647 AsRefStr,
648 EnumIter,
649 EnumString,
650 Serialize,
651 Deserialize,
652)]
653#[serde(rename_all = "snake_case")]
654#[strum(serialize_all = "snake_case")]
655pub enum PaymentType {
656 Ach,
657 Wire,
658 Crypto,
659 Debit,
660 Apm,
661}
662
663#[derive(
665 Debug,
666 Clone,
667 Copy,
668 PartialEq,
669 Eq,
670 Hash,
671 Display,
672 AsRefStr,
673 EnumIter,
674 EnumString,
675 Serialize,
676 Deserialize,
677)]
678#[serde(rename_all = "snake_case")]
679#[strum(serialize_all = "snake_case")]
680pub enum OrderAction {
681 Buy,
682 Sell,
683 SellPartial,
684 SellToClose,
685 #[serde(rename = "")]
686 #[strum(serialize = "")]
687 Unknown,
688}
689
690#[derive(
692 Debug,
693 Clone,
694 PartialEq,
695 Eq,
696 Hash,
697 Display,
698 AsRefStr,
699 EnumIter,
700 EnumString,
701 Serialize,
702 Deserialize,
703)]
704#[serde(rename_all = "snake_case")]
705#[strum(serialize_all = "snake_case")]
706pub enum OrderType {
707 Limit,
708 Market,
709 #[serde(untagged)]
710 #[strum(default, transparent)]
711 Other(String),
712}
713
714#[derive(
716 Debug,
717 Clone,
718 Copy,
719 PartialEq,
720 Eq,
721 Hash,
722 Display,
723 AsRefStr,
724 EnumIter,
725 EnumString,
726 Serialize,
727 Deserialize,
728)]
729#[serde(rename_all = "snake_case")]
730#[strum(serialize_all = "snake_case")]
731pub enum IncentiveType {
732 Liquidity,
733 Volume,
734 MarginMakerVolume,
735 MarginTakerVolume,
736}
737
738#[derive(
740 Debug,
741 Clone,
742 Copy,
743 PartialEq,
744 Eq,
745 Hash,
746 Display,
747 AsRefStr,
748 EnumIter,
749 EnumString,
750 Serialize,
751 Deserialize,
752)]
753#[serde(rename_all = "snake_case")]
754#[strum(serialize_all = "snake_case")]
755pub enum RestingMarginReservation {
756 None,
757 Max,
758 Sum,
759}
760
761#[derive(
763 Debug,
764 Clone,
765 Copy,
766 PartialEq,
767 Eq,
768 Hash,
769 Display,
770 AsRefStr,
771 EnumIter,
772 EnumString,
773 Serialize,
774 Deserialize,
775)]
776#[serde(rename_all = "snake_case")]
777#[strum(serialize_all = "snake_case")]
778pub enum TransferStatus {
779 Pending,
780 Complete,
781}
782
783#[derive(
785 Debug,
786 Clone,
787 Copy,
788 PartialEq,
789 Eq,
790 Hash,
791 Display,
792 AsRefStr,
793 EnumIter,
794 EnumString,
795 Serialize,
796 Deserialize,
797)]
798#[serde(rename_all = "snake_case")]
799#[strum(serialize_all = "snake_case")]
800pub enum RfqStatus {
801 Open,
802 Closed,
803}
804
805#[derive(
807 Debug,
808 Clone,
809 Copy,
810 PartialEq,
811 Eq,
812 Hash,
813 Display,
814 AsRefStr,
815 EnumIter,
816 EnumString,
817 Serialize,
818 Deserialize,
819)]
820#[serde(rename_all = "snake_case")]
821#[strum(serialize_all = "snake_case")]
822pub enum QuoteStatus {
823 Open,
824 Accepted,
825 Confirmed,
826 Executed,
827 Cancelled,
828}
829
830#[derive(
832 Debug,
833 Clone,
834 Copy,
835 PartialEq,
836 Eq,
837 Hash,
838 Display,
839 AsRefStr,
840 EnumIter,
841 EnumString,
842 Serialize,
843 Deserialize,
844)]
845#[serde(rename_all = "snake_case")]
846#[strum(serialize_all = "snake_case")]
847pub enum RfqBatchStatus {
848 Open,
849 Accepted,
850 Closed,
851}
852
853#[derive(
855 Debug,
856 Clone,
857 Copy,
858 PartialEq,
859 Eq,
860 Hash,
861 Display,
862 AsRefStr,
863 EnumIter,
864 EnumString,
865 Serialize,
866 Deserialize,
867)]
868#[serde(rename_all = "snake_case")]
869#[strum(serialize_all = "snake_case")]
870pub enum RfqBatchQuoteStatus {
871 Open,
872 Accepted,
873 Confirmed,
874 Executed,
875 PartiallyExecuted,
876 Cancelled,
877}
878
879#[derive(
881 Debug,
882 Clone,
883 PartialEq,
884 Eq,
885 Hash,
886 Display,
887 AsRefStr,
888 EnumIter,
889 EnumString,
890 Serialize,
891 Deserialize,
892)]
893#[serde(rename_all = "snake_case")]
894#[strum(serialize_all = "snake_case")]
895pub enum MarketType {
896 Binary,
897 Scalar,
898 #[serde(untagged)]
899 #[strum(default, transparent)]
900 Other(String),
901}
902
903#[derive(
905 Debug,
906 Clone,
907 PartialEq,
908 Eq,
909 Hash,
910 Display,
911 AsRefStr,
912 EnumIter,
913 EnumString,
914 Serialize,
915 Deserialize,
916)]
917#[serde(rename_all = "snake_case")]
918#[strum(serialize_all = "snake_case")]
919pub enum MarketStatus {
920 Initialized,
921 Inactive,
922 Active,
923 Closed,
924 Determined,
925 Disputed,
926 Amended,
927 Finalized,
928 #[serde(untagged)]
929 #[strum(default, transparent)]
930 Other(String),
931}
932
933#[derive(
935 Debug,
936 Clone,
937 PartialEq,
938 Eq,
939 Hash,
940 Display,
941 AsRefStr,
942 EnumIter,
943 EnumString,
944 Serialize,
945 Deserialize,
946)]
947#[serde(rename_all = "snake_case")]
948#[strum(serialize_all = "snake_case")]
949pub enum SettlementBoundsType {
950 Default,
951 Floor,
952 #[serde(untagged)]
953 #[strum(default, transparent)]
954 Other(String),
955}
956
957#[derive(
959 Debug,
960 Clone,
961 Copy,
962 PartialEq,
963 Eq,
964 Hash,
965 Display,
966 AsRefStr,
967 EnumIter,
968 EnumString,
969 Serialize,
970 Deserialize,
971)]
972#[serde(rename_all = "snake_case")]
973#[strum(serialize_all = "snake_case")]
974pub enum StrikeType {
975 Greater,
976 GreaterOrEqual,
977 Less,
978 LessOrEqual,
979 Between,
980 Functional,
981 Custom,
982 Structured,
983}
984
985#[derive(
987 Debug,
988 Clone,
989 Copy,
990 PartialEq,
991 Eq,
992 Hash,
993 Display,
994 AsRefStr,
995 EnumIter,
996 EnumString,
997 Serialize,
998 Deserialize,
999)]
1000#[serde(rename_all = "PascalCase")]
1001#[strum(serialize_all = "PascalCase")]
1002pub enum OrderUpdateReason {
1003 Decrease,
1004 Amend,
1005 MarginCancel,
1006 SelfTradeCancel,
1007 ExpiryCancel,
1008 CloseCancel,
1009 HaltCancel,
1010 Trade,
1011 PostOnlyCrossCancel,
1012 ReduceOnlyCancel,
1013 SettlementBoundsCancel,
1014}
1015
1016#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter, FromRepr, Serialize, Deserialize)]
1018#[repr(u32)]
1019#[serde(try_from = "u32", into = "u32")]
1020pub enum OrderbookUpdateInterval {
1021 Immediate = 0,
1022 Millis100 = 100,
1023 Millis1000 = 1000,
1024}
1025
1026impl From<OrderbookUpdateInterval> for u32 {
1027 fn from(value: OrderbookUpdateInterval) -> Self {
1028 value as Self
1029 }
1030}
1031
1032impl TryFrom<u32> for OrderbookUpdateInterval {
1033 type Error = strum::ParseError;
1034
1035 fn try_from(value: u32) -> Result<Self, Self::Error> {
1036 Self::from_repr(value).ok_or(strum::ParseError::VariantNotFound)
1037 }
1038}
1039
1040#[derive(
1042 Debug,
1043 Clone,
1044 Copy,
1045 PartialEq,
1046 Eq,
1047 Hash,
1048 Display,
1049 AsRefStr,
1050 EnumIter,
1051 EnumString,
1052 Serialize,
1053 Deserialize,
1054)]
1055#[serde(rename_all = "snake_case")]
1056#[strum(serialize_all = "snake_case")]
1057pub enum CfBenchmarksUpdateAction {
1058 SubscribeIndices,
1059 UnsubscribeIndices,
1060 Indexlist,
1061}
1062
1063#[derive(
1065 Debug,
1066 Clone,
1067 Copy,
1068 PartialEq,
1069 Eq,
1070 Hash,
1071 Display,
1072 AsRefStr,
1073 EnumIter,
1074 EnumString,
1075 Serialize,
1076 Deserialize,
1077)]
1078#[serde(rename_all = "snake_case")]
1079#[strum(serialize_all = "snake_case")]
1080pub enum PythUpdateAction {
1081 SubscribeUnderlyings,
1082 UnsubscribeUnderlyings,
1083 UnderlyingList,
1084}
1085
1086#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, EnumIter, FromRepr, Serialize, Deserialize)]
1088#[repr(u32)]
1089#[serde(try_from = "u32", into = "u32")]
1090pub enum KalshiWsErrorCode {
1091 UnableToProcessMessage = 1,
1092 ParamsRequired = 2,
1093 ChannelsRequired = 3,
1094 SubscriptionIdsRequired = 4,
1095 UnknownCommand = 5,
1096 UnknownSubscriptionId = 7,
1097 UnknownChannelName = 8,
1098 AuthenticationRequired = 9,
1099 ChannelError = 10,
1100 InvalidParameter = 11,
1101 ExactlyOneSubscriptionIdRequired = 12,
1102 UnsupportedAction = 13,
1103 MarketTickerRequired = 14,
1104 ActionRequired = 15,
1105 CommandTimeout = 18,
1106 InvalidShardFactor = 19,
1107 ShardFactorRequired = 20,
1108 InvalidShardKey = 21,
1109 ShardFactorTooLarge = 22,
1110 MatchIdsRequired = 23,
1111 IndexIdsRequired = 24,
1112 SubscriptionBufferOverflow = 25,
1113 SubscriptionMarketLimitExceeded = 26,
1114 TooManyRequests = 27,
1115 UnderlyingTickersRequired = 28,
1116 InvalidUpdateInterval = 29,
1117}
1118
1119impl From<KalshiWsErrorCode> for u32 {
1120 fn from(value: KalshiWsErrorCode) -> Self {
1121 value as Self
1122 }
1123}
1124
1125impl TryFrom<u32> for KalshiWsErrorCode {
1126 type Error = strum::ParseError;
1127
1128 fn try_from(value: u32) -> Result<Self, Self::Error> {
1129 Self::from_repr(value).ok_or(strum::ParseError::VariantNotFound)
1130 }
1131}
1132
1133#[derive(
1135 Debug,
1136 Clone,
1137 Copy,
1138 PartialEq,
1139 Eq,
1140 Hash,
1141 Display,
1142 AsRefStr,
1143 EnumIter,
1144 EnumString,
1145 Serialize,
1146 Deserialize,
1147)]
1148#[serde(rename_all = "snake_case")]
1149#[strum(serialize_all = "snake_case")]
1150pub enum MarketLifecycleEvent {
1151 Created,
1152 Deactivated,
1153 Activated,
1154 CloseDateUpdated,
1155 Determined,
1156 Settled,
1157 PriceLevelStructureUpdated,
1158 MetadataUpdated,
1159}
1160
1161#[derive(
1163 Debug,
1164 Clone,
1165 Copy,
1166 PartialEq,
1167 Eq,
1168 Hash,
1169 Display,
1170 AsRefStr,
1171 EnumIter,
1172 EnumString,
1173 Serialize,
1174 Deserialize,
1175)]
1176#[serde(rename_all = "snake_case")]
1177#[strum(serialize_all = "snake_case")]
1178pub enum MultivariateMarketLifecycleEvent {
1179 Created,
1180 Deactivated,
1181 Activated,
1182 CloseDateUpdated,
1183 Determined,
1184 Settled,
1185}
1186
1187#[derive(
1189 Debug,
1190 Clone,
1191 PartialEq,
1192 Eq,
1193 Hash,
1194 Display,
1195 AsRefStr,
1196 EnumIter,
1197 EnumString,
1198 Serialize,
1199 Deserialize,
1200)]
1201#[serde(rename_all = "snake_case")]
1202#[strum(serialize_all = "snake_case")]
1203pub enum PriceLevelStructure {
1204 BandedCentiCent,
1205 #[serde(rename = "")]
1206 #[strum(serialize = "")]
1207 Unknown,
1208 LinearCent,
1209 DeciCent,
1210 TaperedDeciCent,
1211 CenterWholeEdgeHalfCent,
1212 CenterWholeEdgeQuintCent,
1213 CenterHalfEdgeHalfCent,
1214 CenterHalfEdgeQuintCent,
1215 CenterHalfEdgeDeciCent,
1216 CenterQuintEdgeQuintCent,
1217 CenterQuintEdgeDeciCent,
1218 CenterCentiEdgeCentiCent,
1219 CenterDeciEdgeCentiCent,
1220 #[serde(untagged)]
1221 #[strum(default, transparent)]
1222 Other(String),
1223}
1224
1225#[derive(
1227 Debug,
1228 Clone,
1229 PartialEq,
1230 Eq,
1231 Hash,
1232 Display,
1233 AsRefStr,
1234 EnumIter,
1235 EnumString,
1236 Serialize,
1237 Deserialize,
1238)]
1239#[serde(rename_all = "snake_case")]
1240#[strum(serialize_all = "snake_case")]
1241pub enum CollateralReturnType {
1242 #[serde(rename = "MECNET")]
1243 #[strum(serialize = "MECNET")]
1244 Mecnet,
1245 #[serde(rename = "DIRECNET")]
1246 #[strum(serialize = "DIRECNET")]
1247 Direcnet,
1248 #[serde(rename = "")]
1249 #[strum(serialize = "")]
1250 None,
1251 #[serde(untagged)]
1252 #[strum(default, transparent)]
1253 Other(String),
1254}
1255
1256#[derive(
1258 Debug,
1259 Clone,
1260 Copy,
1261 PartialEq,
1262 Eq,
1263 Hash,
1264 Display,
1265 AsRefStr,
1266 EnumIter,
1267 EnumString,
1268 Serialize,
1269 Deserialize,
1270)]
1271#[serde(rename_all = "snake_case")]
1272#[strum(serialize_all = "snake_case")]
1273pub enum OrderGroupEvent {
1274 Created,
1275 Triggered,
1276 Reset,
1277 Deleted,
1278 LimitUpdated,
1279}
1280
1281#[derive(
1283 Debug,
1284 Clone,
1285 PartialEq,
1286 Eq,
1287 Hash,
1288 Display,
1289 AsRefStr,
1290 EnumIter,
1291 EnumString,
1292 Serialize,
1293 Deserialize,
1294)]
1295#[serde(rename_all = "snake_case")]
1296#[strum(serialize_all = "snake_case")]
1297pub enum ApiUsageTier {
1298 Basic,
1299 Advanced,
1300 Expert,
1301 Premier,
1302 Paragon,
1303 Prime,
1304 Prestige,
1305 #[serde(untagged)]
1306 #[strum(default, transparent)]
1307 Other(String),
1308}
1309
1310#[derive(
1312 Debug,
1313 Clone,
1314 PartialEq,
1315 Eq,
1316 Hash,
1317 Display,
1318 AsRefStr,
1319 EnumIter,
1320 EnumString,
1321 Serialize,
1322 Deserialize,
1323)]
1324#[serde(rename_all = "snake_case")]
1325#[strum(serialize_all = "snake_case")]
1326pub enum UsageGrantSource {
1327 Volume,
1328 Manual,
1329 #[serde(untagged)]
1330 #[strum(default, transparent)]
1331 Other(String),
1332}
1333
1334#[derive(
1336 Debug,
1337 Clone,
1338 Copy,
1339 PartialEq,
1340 Eq,
1341 Hash,
1342 Display,
1343 AsRefStr,
1344 EnumIter,
1345 EnumString,
1346 Serialize,
1347 Deserialize,
1348)]
1349#[serde(rename_all = "snake_case")]
1350#[strum(serialize_all = "snake_case")]
1351pub enum PositionCountFilter {
1352 Position,
1353 TotalTraded,
1354}
1355
1356#[derive(
1358 Debug,
1359 Clone,
1360 Copy,
1361 PartialEq,
1362 Eq,
1363 Hash,
1364 Display,
1365 AsRefStr,
1366 EnumIter,
1367 EnumString,
1368 Serialize,
1369 Deserialize,
1370)]
1371#[serde(rename_all = "snake_case")]
1372#[strum(serialize_all = "snake_case")]
1373pub enum OrderStatusFilter {
1374 Resting,
1375 Canceled,
1376 Executed,
1377}
1378
1379#[derive(
1381 Debug,
1382 Clone,
1383 Copy,
1384 PartialEq,
1385 Eq,
1386 Hash,
1387 Display,
1388 AsRefStr,
1389 EnumIter,
1390 EnumString,
1391 Serialize,
1392 Deserialize,
1393)]
1394#[serde(rename_all = "snake_case")]
1395#[strum(serialize_all = "snake_case")]
1396pub enum KalshiCommandKind {
1397 Subscribe,
1398 Unsubscribe,
1399 UpdateSubscription,
1400 ListSubscriptions,
1401}
1402
1403#[cfg(test)]
1404mod tests {
1405 use rstest::rstest;
1406
1407 use super::*;
1408
1409 #[rstest]
1410 fn test_environment_default_is_production() {
1411 assert_eq!(KalshiEnvironment::default(), KalshiEnvironment::Production);
1412 }
1413}