hank-types 0.1.41

Generated type definitions for Hank
Documentation 
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

// Customizations from hank.plugin.customizations.rs
#[cfg(feature = "builder")]
#[derive(Debug)]
pub enum AccessChecks {
    Array(Vec<crate::access_check::AccessCheck>),
    Single(crate::access_check::AccessCheck),
    Full(crate::access_check::AccessCheckChain),
}
#[cfg(feature = "builder")]
impl Metadata {
    pub fn new(
        name: impl Into<String>,
        author: impl Into<String>,
        description: impl Into<String>,
        version: impl Into<String>,
    ) -> MetadataBuilder {
        MetadataBuilder {
            name: Some(name.into()),
            author: Some(author.into()),
            description: Some(description.into()),
            version: Some(version.into()),
            ..MetadataBuilder::create_empty()
        }
    }
}
#[cfg(feature = "builder")]
impl MetadataBuilder {
    pub fn allowed_hosts(
        &mut self,
        value: impl IntoIterator<Item = impl Into<String>>,
    ) -> &mut Self {
        self.allowed_hosts = Some(value.into_iter().map(Into::into).collect());
        self
    }
    pub fn aliases(&mut self, value: impl IntoIterator<Item = impl Into<String>>) -> &mut Self {
        self.aliases = Some(value.into_iter().map(Into::into).collect());
        self
    }
    pub fn escalation_key(&mut self, value: impl Into<String>) -> &mut Self {
        self.escalation_key = Some(Some(value.into()));
        self
    }
    pub fn escalated_privileges(
        &mut self,
        value: impl IntoIterator<Item = impl Into<i32>>,
    ) -> &mut Self {
        self.escalated_privileges = Some(value.into_iter().map(Into::into).collect());
        self
    }
    pub fn access_checks(&mut self, value: AccessChecks) -> &mut Self {
        self.access_checks = Some(match value {
            AccessChecks::Array(checks) => Some(crate::access_check::AccessCheckChain {
                operator: crate::access_check::AccessCheckOperator::Or.into(),
                checks,
            }),
            AccessChecks::Single(check) => Some(crate::access_check::AccessCheckChain {
                operator: crate::access_check::AccessCheckOperator::Or.into(),
                checks: vec![check],
            }),
            AccessChecks::Full(full) => Some(full),
        });
        self
    }
    pub fn build(&self) -> Metadata {
        self.fallible_build()
            .expect("All required fields were initialized")
    }
}
#[cfg(feature = "builder")]
impl Command {
    pub fn new(name: impl Into<String>, description: impl Into<String>) -> CommandBuilder {
        CommandBuilder {
            name: Some(name.into()),
            description: Some(description.into()),
            ..CommandBuilder::create_empty()
        }
    }
}
#[cfg(feature = "builder")]
impl CommandBuilder {
    pub fn build(&self) -> Command {
        self.fallible_build()
            .expect("All required fields were initialized")
    }
}
#[cfg(feature = "builder")]
impl Argument {
    pub fn new(name: impl Into<String>, description: impl Into<String>) -> ArgumentBuilder {
        ArgumentBuilder {
            name: Some(name.into()),
            description: Some(description.into()),
            ..ArgumentBuilder::create_empty()
        }
    }
}
#[cfg(feature = "builder")]
impl ArgumentBuilder {
    pub fn build(&self) -> Argument {
        self.fallible_build()
            .expect("All required fields were initialized")
    }
}