eio_okta_data/
lib.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
#![allow(non_camel_case_types)]

#[cfg(feature = "comparable")]
pub mod comparable;

pub mod v2024_07_0;
pub use v2024_07_0 as current;

macro_rules! impl_from {
  ($from:ty => $into:ty as $field:ident) => {
    impl From<$from> for $into {
      fn from(value: $from) -> Self {
        value.$field
      }
    }
  };
}

pub(crate) use impl_from;

macro_rules! impl_as_ref {
  ($self:ty) => {
    impl AsRef<$self> for $self {
      fn as_ref(&self) -> &$self {
        &self
      }
    }
  };
  ($self:ty => $referent:ty as $field:ident) => {
    impl AsRef<$referent> for $self {
      fn as_ref(&self) -> &$referent {
        self.$field.as_ref()
      }
    }
  };
}

pub(crate) use impl_as_ref;

#[macro_use]
pub(crate) extern crate macro_rules_attribute;
pub(crate) use macro_rules_attribute::apply;
pub(crate) use macro_rules_attribute::attribute_alias;

attribute_alias! {
  #[apply(structs)] =
    #[derive(crate::macro_rules_attribute::Custom)]
    #[cfg_attr(feature = "educe", derive(::educe::Educe))]
    #[cfg_attr(feature = "educe", educe(Debug, Clone, PartialEq, Eq, Hash))]
    #[cfg_attr(feature = "arbitrary",  derive(::arbitrary::Arbitrary))]
    #[cfg_attr(feature = "builder",    derive(::derive_builder::Builder))]
    #[cfg_attr(feature = "builder",    builder(setter(into)))]
    #[cfg_attr(feature = "comparable", derive(::comparable::Comparable))]
    #[cfg_attr(feature = "dummy",      derive(::fake::Dummy))]
    #[cfg_attr(feature = "proptest",   derive(::proptest_derive::Arbitrary))]
    #[cfg_attr(feature = "schemars",   derive(::schemars::JsonSchema))]
    #[cfg_attr(feature = "serde",      derive(::serde::Deserialize))]
    #[cfg_attr(feature = "serde",      derive(::serde::Serialize))]
    #[cfg_attr(feature = "patch",      derive(::struct_patch::Patch))]
    #[cfg_attr(feature = "validate",   derive(::validator::Validate))]
    #[cfg_attr(all(feature = "patch", feature = "educe"),      patch(attribute(derive(::educe::Educe))))]
    #[cfg_attr(all(feature = "patch", feature = "educe"),      patch(attribute(educe(Debug, Clone, PartialEq, Hash, Default))))]
    #[cfg_attr(all(feature = "patch", feature = "builder"),    patch(attribute(derive(::derive_builder::Builder))))]
    #[cfg_attr(all(feature = "patch", feature = "builder"),    patch(attribute(builder(default, setter(into)))))]
    #[cfg_attr(all(feature = "patch", feature = "schemars"),   patch(attribute(derive(::schemars::JsonSchema))))]
    #[cfg_attr(all(feature = "patch", feature = "serde"),      patch(attribute(derive(::serde::Deserialize))))]
    #[cfg_attr(all(feature = "patch", feature = "serde"),      patch(attribute(derive(::serde::Serialize))))]
    #[cfg_attr(all(feature = "patch", feature = "validate"),   patch(attribute(derive(::validator::Validate))))]
    #[cfg_attr(all(feature = "patch", feature = "comparable"), patch(attribute(derive(::comparable::Comparable))))]
  ;

  #[apply(structs_with_args)] =
    #[crate::apply(crate::structs)]
    #[cfg_attr(feature = "clap",         derive(::clap::Args))]
  ;

  // #[apply(structs_with_parser)] =
  //   #[crate::apply(crate::structs)]
  //   #[cfg_attr(feature = "clap",         derive(::clap::Parser))]
  // ;

  #[apply(enums)] =
    #[cfg_attr(feature = "educe",      derive(::educe::Educe))]
    #[cfg_attr(feature = "educe",      educe(Debug, Clone, PartialEq, Eq, Hash))]
    #[cfg_attr(feature = "arbitrary",  derive(::arbitrary::Arbitrary))]
    #[cfg_attr(feature = "clap",       derive(::clap::ValueEnum))]
    #[cfg_attr(feature = "comparable", derive(::comparable::Comparable))]
    #[cfg_attr(feature = "dummy",      derive(::fake::Dummy))]
    #[cfg_attr(feature = "proptest",   derive(::proptest_derive::Arbitrary))]
    #[cfg_attr(feature = "schemars",   derive(::schemars::JsonSchema))]
    #[cfg_attr(feature = "serde",      derive(::serde::Deserialize))]
    #[cfg_attr(feature = "serde",      derive(::serde::Serialize))]
    #[cfg_attr(feature = "strum",      derive(::strum::AsRefStr))]
    #[cfg_attr(feature = "strum",      derive(::strum::Display))]
    #[cfg_attr(feature = "strum",      derive(::strum::EnumCount))]
    #[cfg_attr(feature = "strum",      derive(::strum::EnumDiscriminants))]
    #[cfg_attr(feature = "strum",      derive(::strum::EnumIs))]
    #[cfg_attr(feature = "strum",      derive(::strum::EnumIter))]
    #[cfg_attr(feature = "strum",      derive(::strum::EnumMessage))]
    #[cfg_attr(feature = "strum",      derive(::strum::EnumProperty))]
    #[cfg_attr(feature = "strum",      derive(::strum::EnumString))]
    #[cfg_attr(feature = "strum",      derive(::strum::EnumTryAs))]
    #[cfg_attr(feature = "strum",      derive(::strum::FromRepr))]
    #[cfg_attr(feature = "strum",      derive(::strum::IntoStaticStr))]
    #[cfg_attr(feature = "strum",      derive(::strum::VariantArray))]
    #[cfg_attr(feature = "strum",      derive(::strum::VariantNames))]
  ;

  // #[apply(errors)] =
  //   #[cfg_attr(feature = "educe",      derive(::educe::Educe))]
  //   #[cfg_attr(feature = "educe",      educe(Debug))]
  //   #[cfg_attr(feature = "errors",     derive(::thiserror::Error))]
  //   #[cfg_attr(feature = "diagnostic", derive(::miette::Diagnostic))]
  // ;

}

#[cfg(feature = "dummy")]
pub(crate) mod fake;

#[cfg(feature = "proptest")]
pub(crate) mod strategy;

#[cfg(test)]
pub(crate) mod testing;