#[derive(Clone, serde::Serialize, serde::Deserialize)]
pub struct CertificateIssueRequestInput {
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "domains")]
pub domains: Vec<String>,
#[serde(
rename = "key_algorithm",
default,
skip_serializing_if = "Option::is_none"
)]
pub key_algorithm: Option<CertificateKeyAlgorithmInput>,
#[serde(rename = "source", default, skip_serializing_if = "Option::is_none")]
pub source: Option<CertificateSourceInput>,
#[serde(
rename = "certificate_pem",
default,
skip_serializing_if = "Option::is_none"
)]
pub certificate_pem: Option<String>,
#[serde(rename = "chain_pem", default, skip_serializing_if = "Option::is_none")]
pub chain_pem: Option<String>,
#[serde(
rename = "private_key_pem",
default,
skip_serializing_if = "Option::is_none"
)]
pub private_key_pem: Option<String>,
#[serde(rename = "tags", default, skip_serializing_if = "Option::is_none")]
pub tags: Option<TagsInput>,
}
impl std::fmt::Debug for CertificateIssueRequestInput {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut d = f.debug_struct("CertificateIssueRequestInput");
d.field("name", &self.name);
d.field("domains", &self.domains);
d.field("key_algorithm", &self.key_algorithm);
d.field("source", &self.source);
d.field("certificate_pem", &self.certificate_pem);
d.field("chain_pem", &self.chain_pem);
d.field("private_key_pem", &"[REDACTED]");
d.field("tags", &self.tags);
d.finish()
}
}
impl CertificateIssueRequestInput {
#[allow(clippy::too_many_arguments)]
pub fn new(name: String, domains: Vec<String>) -> Self {
Self {
name,
domains,
key_algorithm: None,
source: None,
certificate_pem: None,
chain_pem: None,
private_key_pem: None,
tags: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CertificateKeyAlgorithmInput {
EcdsaP256,
EcdsaP384,
Rsa2048,
Rsa4096,
Unknown(String),
}
impl CertificateKeyAlgorithmInput {
pub fn as_str(&self) -> &str {
match self {
Self::EcdsaP256 => "ecdsa-p256",
Self::EcdsaP384 => "ecdsa-p384",
Self::Rsa2048 => "rsa-2048",
Self::Rsa4096 => "rsa-4096",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for CertificateKeyAlgorithmInput {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for CertificateKeyAlgorithmInput {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"ecdsa-p256" => Self::EcdsaP256,
"ecdsa-p384" => Self::EcdsaP384,
"rsa-2048" => Self::Rsa2048,
"rsa-4096" => Self::Rsa4096,
_ => Self::Unknown(value),
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CertificateSourceInput {
Acme,
Uploaded,
Unknown(String),
}
impl CertificateSourceInput {
pub fn as_str(&self) -> &str {
match self {
Self::Acme => "acme",
Self::Uploaded => "uploaded",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for CertificateSourceInput {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for CertificateSourceInput {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"acme" => Self::Acme,
"uploaded" => Self::Uploaded,
_ => Self::Unknown(value),
})
}
}
pub type TagsInput = std::collections::BTreeMap<String, String>;
pub type CreateCertificateBody = CertificateIssueRequestInput;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct CertificateResponse {
#[serde(
rename = "certificate",
default,
skip_serializing_if = "Option::is_none"
)]
pub certificate: Option<Certificate>,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct Certificate {
#[serde(rename = "id", default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "crn", default, skip_serializing_if = "Option::is_none")]
pub crn: Option<String>,
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "domains", default, skip_serializing_if = "Option::is_none")]
pub domains: Option<Vec<String>>,
#[serde(rename = "status", default, skip_serializing_if = "Option::is_none")]
pub status: Option<CertificateStatus>,
#[serde(rename = "source", default, skip_serializing_if = "Option::is_none")]
pub source: Option<CertificateSource>,
#[serde(
rename = "key_algorithm",
default,
skip_serializing_if = "Option::is_none"
)]
pub key_algorithm: Option<CertificateKeyAlgorithm>,
#[serde(
rename = "challenges",
default,
skip_serializing_if = "Option::is_none"
)]
pub challenges: Option<Vec<CertificateChallenge>>,
#[serde(
rename = "certificate_pem",
default,
skip_serializing_if = "Option::is_none"
)]
pub certificate_pem: Option<String>,
#[serde(rename = "chain_pem", default, skip_serializing_if = "Option::is_none")]
pub chain_pem: Option<String>,
#[serde(
rename = "fingerprint",
default,
skip_serializing_if = "Option::is_none"
)]
pub fingerprint: Option<String>,
#[serde(rename = "issued_at", default, skip_serializing_if = "Option::is_none")]
pub issued_at: Option<String>,
#[serde(
rename = "expires_at",
default,
skip_serializing_if = "Option::is_none"
)]
pub expires_at: Option<String>,
#[serde(rename = "faults")]
pub faults: Vec<Fault>,
#[serde(rename = "tags", default, skip_serializing_if = "Option::is_none")]
pub tags: Option<Tags>,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CertificateStatus {
PendingDns,
Pending,
Active,
Error,
Expired,
Revoked,
Unknown(String),
}
impl CertificateStatus {
pub fn as_str(&self) -> &str {
match self {
Self::PendingDns => "pending_dns",
Self::Pending => "pending",
Self::Active => "active",
Self::Error => "error",
Self::Expired => "expired",
Self::Revoked => "revoked",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for CertificateStatus {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for CertificateStatus {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"pending_dns" => Self::PendingDns,
"pending" => Self::Pending,
"active" => Self::Active,
"error" => Self::Error,
"expired" => Self::Expired,
"revoked" => Self::Revoked,
_ => Self::Unknown(value),
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CertificateSource {
Acme,
Uploaded,
Unknown(String),
}
impl CertificateSource {
pub fn as_str(&self) -> &str {
match self {
Self::Acme => "acme",
Self::Uploaded => "uploaded",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for CertificateSource {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for CertificateSource {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"acme" => Self::Acme,
"uploaded" => Self::Uploaded,
_ => Self::Unknown(value),
})
}
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum CertificateKeyAlgorithm {
EcdsaP256,
EcdsaP384,
Rsa2048,
Rsa4096,
Unknown(String),
}
impl CertificateKeyAlgorithm {
pub fn as_str(&self) -> &str {
match self {
Self::EcdsaP256 => "ecdsa-p256",
Self::EcdsaP384 => "ecdsa-p384",
Self::Rsa2048 => "rsa-2048",
Self::Rsa4096 => "rsa-4096",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for CertificateKeyAlgorithm {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for CertificateKeyAlgorithm {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"ecdsa-p256" => Self::EcdsaP256,
"ecdsa-p384" => Self::EcdsaP384,
"rsa-2048" => Self::Rsa2048,
"rsa-4096" => Self::Rsa4096,
_ => Self::Unknown(value),
})
}
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct CertificateChallenge {
#[serde(rename = "domain", default, skip_serializing_if = "Option::is_none")]
pub domain: Option<String>,
#[serde(
rename = "cname_record_name",
default,
skip_serializing_if = "Option::is_none"
)]
pub cname_record_name: Option<String>,
#[serde(
rename = "expected_cname",
default,
skip_serializing_if = "Option::is_none"
)]
pub expected_cname: Option<String>,
#[serde(rename = "our_dns", default, skip_serializing_if = "Option::is_none")]
pub our_dns: Option<bool>,
#[serde(rename = "verified", default, skip_serializing_if = "Option::is_none")]
pub verified: Option<bool>,
#[serde(
rename = "verified_at",
default,
skip_serializing_if = "Option::is_none"
)]
pub verified_at: Option<String>,
#[serde(rename = "faults")]
pub faults: Vec<Fault>,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize)]
pub struct Fault {
#[serde(rename = "code")]
pub code: String,
#[serde(rename = "severity")]
pub severity: FaultSeverity,
#[serde(rename = "message")]
pub message: String,
#[serde(rename = "details")]
pub details: crate::Nullable<std::collections::BTreeMap<String, serde_json::Value>>,
#[serde(rename = "first_at")]
pub first_at: String,
#[serde(rename = "last_at")]
pub last_at: String,
#[serde(rename = "occurrences")]
pub occurrences: i64,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub enum FaultSeverity {
Error,
Warning,
Unknown(String),
}
impl FaultSeverity {
pub fn as_str(&self) -> &str {
match self {
Self::Error => "error",
Self::Warning => "warning",
Self::Unknown(value) => value,
}
}
}
impl serde::Serialize for FaultSeverity {
fn serialize<S: serde::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(self.as_str())
}
}
impl<'de> serde::Deserialize<'de> for FaultSeverity {
fn deserialize<D: serde::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let value = <String as serde::Deserialize>::deserialize(deserializer)?;
Ok(match value.as_str() {
"error" => Self::Error,
"warning" => Self::Warning,
_ => Self::Unknown(value),
})
}
}
pub type Tags = std::collections::BTreeMap<String, String>;
pub type CreateCertificateResponse = CertificateResponse;
pub type GetCertificateResponse = CertificateResponse;
pub type GetCertificateResource = Certificate;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct GetCertificateScope {
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct MaterialResponse {
#[serde(rename = "material", default, skip_serializing_if = "Option::is_none")]
pub material: Option<Material>,
}
#[derive(Clone, serde::Serialize, serde::Deserialize, Default)]
pub struct Material {
#[serde(
rename = "certificate_pem",
default,
skip_serializing_if = "Option::is_none"
)]
pub certificate_pem: Option<String>,
#[serde(rename = "chain_pem", default, skip_serializing_if = "Option::is_none")]
pub chain_pem: Option<String>,
#[serde(
rename = "private_key_pem",
default,
skip_serializing_if = "Option::is_none"
)]
pub private_key_pem: Option<String>,
#[serde(
rename = "fingerprint",
default,
skip_serializing_if = "Option::is_none"
)]
pub fingerprint: Option<String>,
}
impl std::fmt::Debug for Material {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut d = f.debug_struct("Material");
d.field("certificate_pem", &self.certificate_pem);
d.field("chain_pem", &self.chain_pem);
d.field("private_key_pem", &"[REDACTED]");
d.field("fingerprint", &self.fingerprint);
d.finish()
}
}
pub type GetCertificateMaterialResponse = MaterialResponse;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct ListCertificatesParameters {
#[serde(rename = "name", default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "crn", default, skip_serializing_if = "Option::is_none")]
pub crn: Option<String>,
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "marker", default, skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
}
pub type ListCertificatesQuery = ListCertificatesParameters;
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct CertificateListResponse {
#[serde(
rename = "certificates",
default,
skip_serializing_if = "Option::is_none"
)]
pub certificates: Option<Vec<Certificate>>,
#[serde(rename = "meta", default, skip_serializing_if = "Option::is_none")]
pub meta: Option<PaginationMeta>,
}
#[derive(Clone, Debug, serde::Serialize, serde::Deserialize, Default)]
pub struct PaginationMeta {
#[serde(rename = "total", default, skip_serializing_if = "Option::is_none")]
pub total: Option<i64>,
#[serde(rename = "limit", default, skip_serializing_if = "Option::is_none")]
pub limit: Option<i64>,
#[serde(rename = "marker", default, skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "has_more", default, skip_serializing_if = "Option::is_none")]
pub has_more: Option<bool>,
}
pub type ListCertificatesResponse = CertificateListResponse;
pub type ListCertificatesItem = Certificate;
pub type RevokeCertificateResponse = CertificateResponse;