Skip to main content

nautilus_kalshi/common/
enums.rs

1// -------------------------------------------------------------------------------------------------
2//  Copyright (C) 2015-2026 Nautech Systems Pty Ltd. All rights reserved.
3//  https://nautechsystems.io
4//
5//  Licensed under the GNU Lesser General Public License Version 3.0 (the "License");
6//  You may not use this file except in compliance with the License.
7//  You may obtain a copy of the License at https://www.gnu.org/licenses/lgpl-3.0.en.html
8//
9//  Unless required by applicable law or agreed to in writing, software
10//  distributed under the License is distributed on an "AS IS" BASIS,
11//  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12//  See the License for the specific language governing permissions and
13//  limitations under the License.
14// -------------------------------------------------------------------------------------------------
15
16//! Kalshi venue enums mirrored from REST and WebSocket payloads.
17//!
18//! Enums with an `Other` variant retain unrecognized wire labels for admission checks and persistence.
19//! Closed enums, including request filters, reject undocumented wire values.
20
21use serde::{Deserialize, Serialize};
22use strum::{AsRefStr, Display, EnumIter, EnumString, FromRepr};
23
24/// Kalshi API environment.
25#[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    /// Production trading environment.
58    #[default]
59    Production,
60    /// Demo trading environment.
61    Demo,
62}
63
64impl KalshiEnvironment {
65    /// Returns `true` when this is the demo environment.
66    #[must_use]
67    pub const fn is_demo(self) -> bool {
68        matches!(self, Self::Demo)
69    }
70}
71
72/// Event-contract exit trigger kind.
73#[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/// Candlestick duration in minutes.
94#[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/// Event discovery status filter.
118#[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/// Forecast history interval; zero selects five-second samples.
142#[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/// Multivariate event collection status filter.
167#[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/// Incentive program status filter.
190#[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/// Incentive program type filter.
215#[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/// Settlement state selected by position queries.
240#[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/// Market discovery status filter, distinct from response lifecycle states.
263#[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/// Multivariate market inclusion in live discovery.
288#[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/// Multivariate market exclusion in archived discovery.
310#[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/// Unit of an event-contract exit slippage limit.
331#[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/// Event-contract exit trigger state.
353#[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/// Exit bracket leg that triggers execution.
379#[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/// Series fee model or event override; unrecognized labels remain available for qualification.
401#[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/// Exchange lane attached to an API usage grant.
428#[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/// Communications creator filter; an empty value selects all users.
452#[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/// Scope granted to an API key.
478#[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/// API request signature algorithm.
518#[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/// Market index session and freshness state.
540#[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/// Credit processing state.
563#[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/// Market settlement outcome; an empty value means no result.
587#[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/// Deposit or withdrawal processing state.
615#[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/// Deposit or withdrawal payment method.
639#[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/// Legacy REST and WebSocket order action; an empty value means unknown.
664#[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/// Venue order type retained in order reports.
691#[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/// Incentive program reward type.
715#[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/// Collateral reservation for resting orders during automatic rebalancing.
739#[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/// Intra-exchange-instance transfer state.
762#[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/// Request-for-quote state.
784#[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/// Request-for-quote quote state; cancellation uses the venue spelling.
806#[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/// Request-for-quote batch state.
831#[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/// Request-for-quote batch quote state.
854#[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/// Venue market type; unsupported families remain available for admission checks.
880#[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/// Market lifecycle state returned in metadata.
904#[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/// Settlement bounds applied to a market.
934#[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/// Market strike evaluation rule.
958#[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/// Reason for the most recent private order update.
986#[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/// Order-book conflation interval in milliseconds; zero disables conflation.
1017#[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/// CF Benchmarks subscription update action.
1041#[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/// Pyth subscription update action.
1064#[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/// Documented WebSocket error code; retired codes remain reserved.
1087#[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/// Market lifecycle notification kind.
1134#[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/// Multivariate market lifecycle notification kind.
1162#[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/// Venue price-grid label; price ranges define the actual valid ticks.
1188#[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/// Event collateral netting scheme; an empty value disables netting.
1226#[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/// Order-group lifecycle notification kind.
1257#[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/// Published API usage tier; unrecognized tiers retain conservative quota handling.
1282#[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/// Origin of an API usage-level grant.
1311#[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/// Position field required to have a nonzero value.
1335#[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/// Order report status filter.
1357#[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/// WebSocket client command name.
1380#[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}