#![allow(non_camel_case_types)]
#![allow(unused_imports)]
use serde::de::{value, Deserializer, IntoDeserializer};
use serde::{Deserialize, Serialize, Serializer};
use std::str::FromStr;
#[doc = "Information on the azure container registry"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Acr {
#[doc = "ACR subscription id"]
#[serde(rename = "acrSubscriptionId", default, skip_serializing_if = "Option::is_none")]
pub acr_subscription_id: Option<String>,
#[doc = "ACR resource group"]
#[serde(rename = "acrResourceGroup", default, skip_serializing_if = "Option::is_none")]
pub acr_resource_group: Option<String>,
#[doc = "ACR registry"]
#[serde(rename = "acrRegistryName", default, skip_serializing_if = "Option::is_none")]
pub acr_registry_name: Option<String>,
#[doc = "ACR repository"]
#[serde(rename = "acrRepositoryName", default, skip_serializing_if = "Option::is_none")]
pub acr_repository_name: Option<String>,
}
impl Acr {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Properties used for generating artifacts such as Dockerfiles and manifests."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ArtifactGenerationProperties {
#[doc = "The programming language used."]
#[serde(rename = "generationLanguage", default, skip_serializing_if = "Option::is_none")]
pub generation_language: Option<GenerationLanguage>,
#[doc = "The version of the language image used for execution in the generated dockerfile."]
#[serde(rename = "languageVersion", default, skip_serializing_if = "Option::is_none")]
pub language_version: Option<String>,
#[doc = "The version of the language image used for building the code in the generated dockerfile."]
#[serde(rename = "builderVersion", default, skip_serializing_if = "Option::is_none")]
pub builder_version: Option<String>,
#[doc = "The port the application is exposed on."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub port: Option<String>,
#[doc = "The name of the app."]
#[serde(rename = "appName", default, skip_serializing_if = "Option::is_none")]
pub app_name: Option<String>,
#[doc = "The directory to output the generated Dockerfile to."]
#[serde(rename = "dockerfileOutputDirectory", default, skip_serializing_if = "Option::is_none")]
pub dockerfile_output_directory: Option<String>,
#[doc = "The directory to output the generated manifests to."]
#[serde(rename = "manifestOutputDirectory", default, skip_serializing_if = "Option::is_none")]
pub manifest_output_directory: Option<String>,
#[doc = "The mode of generation to be used for generating Dockerfiles."]
#[serde(rename = "dockerfileGenerationMode", default, skip_serializing_if = "Option::is_none")]
pub dockerfile_generation_mode: Option<DockerfileGenerationMode>,
#[doc = "The mode of generation to be used for generating Manifest."]
#[serde(rename = "manifestGenerationMode", default, skip_serializing_if = "Option::is_none")]
pub manifest_generation_mode: Option<ManifestGenerationMode>,
#[doc = "Determines the type of manifests to be generated."]
#[serde(rename = "manifestType", default, skip_serializing_if = "Option::is_none")]
pub manifest_type: Option<GenerationManifestType>,
#[doc = "The name of the image to be generated."]
#[serde(rename = "imageName", default, skip_serializing_if = "Option::is_none")]
pub image_name: Option<String>,
#[doc = "The namespace to deploy the application to."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub namespace: Option<String>,
#[doc = "The tag to apply to the generated image."]
#[serde(rename = "imageTag", default, skip_serializing_if = "Option::is_none")]
pub image_tag: Option<String>,
}
impl ArtifactGenerationProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Determines the authorization status of requests."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "AuthorizationStatus")]
pub enum AuthorizationStatus {
Authorized,
NotFound,
Error,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for AuthorizationStatus {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for AuthorizationStatus {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for AuthorizationStatus {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Authorized => serializer.serialize_unit_variant("AuthorizationStatus", 0u32, "Authorized"),
Self::NotFound => serializer.serialize_unit_variant("AuthorizationStatus", 1u32, "NotFound"),
Self::Error => serializer.serialize_unit_variant("AuthorizationStatus", 2u32, "Error"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "delete response if content must be provided on delete operation"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DeleteWorkflowResponse {
#[doc = "delete status message"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
impl DeleteWorkflowResponse {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct DeploymentProperties {
#[doc = "Determines the type of manifests within the repository."]
#[serde(rename = "manifestType", default, skip_serializing_if = "Option::is_none")]
pub manifest_type: Option<ManifestType>,
#[serde(
rename = "kubeManifestLocations",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub kube_manifest_locations: Vec<String>,
#[doc = "Helm chart directory path in repository."]
#[serde(rename = "helmChartPath", default, skip_serializing_if = "Option::is_none")]
pub helm_chart_path: Option<String>,
#[doc = "Helm Values.yaml file location in repository."]
#[serde(rename = "helmValues", default, skip_serializing_if = "Option::is_none")]
pub helm_values: Option<String>,
#[doc = "Manifest override values."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub overrides: Option<serde_json::Value>,
}
impl DeploymentProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The mode of generation to be used for generating Dockerfiles."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "DockerfileGenerationMode")]
pub enum DockerfileGenerationMode {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "disabled")]
Disabled,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for DockerfileGenerationMode {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for DockerfileGenerationMode {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for DockerfileGenerationMode {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Enabled => serializer.serialize_unit_variant("DockerfileGenerationMode", 0u32, "enabled"),
Self::Disabled => serializer.serialize_unit_variant("DockerfileGenerationMode", 1u32, "disabled"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "The resource management error additional info."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ErrorAdditionalInfo {
#[doc = "The additional info type."]
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[doc = "The additional info."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub info: Option<serde_json::Value>,
}
impl ErrorAdditionalInfo {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The error detail."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ErrorDetail {
#[doc = "The error code."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[doc = "The error message."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[doc = "The error target."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
#[doc = "The error details."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub details: Vec<ErrorDetail>,
#[doc = "The error additional info."]
#[serde(
rename = "additionalInfo",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub additional_info: Vec<ErrorAdditionalInfo>,
}
impl ErrorDetail {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Common error response for all Azure Resource Manager APIs to return error details for failed operations. (This also follows the OData error response format.)."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ErrorResponse {
#[doc = "The error detail."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub error: Option<ErrorDetail>,
}
impl azure_core::Continuable for ErrorResponse {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
None
}
}
impl ErrorResponse {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ExportTemplateRequest {
#[doc = "Template Name"]
#[serde(rename = "templateName", default, skip_serializing_if = "Option::is_none")]
pub template_name: Option<String>,
#[serde(
rename = "resourceGroupIds",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub resource_group_ids: Vec<String>,
#[serde(rename = "siteId", default, skip_serializing_if = "Option::is_none")]
pub site_id: Option<String>,
#[serde(rename = "instanceName", default, skip_serializing_if = "Option::is_none")]
pub instance_name: Option<String>,
#[serde(rename = "instanceStage", default, skip_serializing_if = "Option::is_none")]
pub instance_stage: Option<String>,
}
impl ExportTemplateRequest {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Dockerfile and manifest artifacts generated as a preview are returned as a map<path string,content string>"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct GeneratePreviewArtifactsResponse {}
impl GeneratePreviewArtifactsResponse {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The programming language used."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "GenerationLanguage")]
pub enum GenerationLanguage {
#[serde(rename = "clojure")]
Clojure,
#[serde(rename = "csharp")]
Csharp,
#[serde(rename = "erlang")]
Erlang,
#[serde(rename = "go")]
Go,
#[serde(rename = "gomodule")]
Gomodule,
#[serde(rename = "gradle")]
Gradle,
#[serde(rename = "java")]
Java,
#[serde(rename = "javascript")]
Javascript,
#[serde(rename = "php")]
Php,
#[serde(rename = "python")]
Python,
#[serde(rename = "ruby")]
Ruby,
#[serde(rename = "rust")]
Rust,
#[serde(rename = "swift")]
Swift,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for GenerationLanguage {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for GenerationLanguage {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for GenerationLanguage {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Clojure => serializer.serialize_unit_variant("GenerationLanguage", 0u32, "clojure"),
Self::Csharp => serializer.serialize_unit_variant("GenerationLanguage", 1u32, "csharp"),
Self::Erlang => serializer.serialize_unit_variant("GenerationLanguage", 2u32, "erlang"),
Self::Go => serializer.serialize_unit_variant("GenerationLanguage", 3u32, "go"),
Self::Gomodule => serializer.serialize_unit_variant("GenerationLanguage", 4u32, "gomodule"),
Self::Gradle => serializer.serialize_unit_variant("GenerationLanguage", 5u32, "gradle"),
Self::Java => serializer.serialize_unit_variant("GenerationLanguage", 6u32, "java"),
Self::Javascript => serializer.serialize_unit_variant("GenerationLanguage", 7u32, "javascript"),
Self::Php => serializer.serialize_unit_variant("GenerationLanguage", 8u32, "php"),
Self::Python => serializer.serialize_unit_variant("GenerationLanguage", 9u32, "python"),
Self::Ruby => serializer.serialize_unit_variant("GenerationLanguage", 10u32, "ruby"),
Self::Rust => serializer.serialize_unit_variant("GenerationLanguage", 11u32, "rust"),
Self::Swift => serializer.serialize_unit_variant("GenerationLanguage", 12u32, "swift"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Determines the type of manifests to be generated."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "GenerationManifestType")]
pub enum GenerationManifestType {
#[serde(rename = "helm")]
Helm,
#[serde(rename = "kube")]
Kube,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for GenerationManifestType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for GenerationManifestType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for GenerationManifestType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Helm => serializer.serialize_unit_variant("GenerationManifestType", 0u32, "helm"),
Self::Kube => serializer.serialize_unit_variant("GenerationManifestType", 1u32, "kube"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "GitHubOAuth request object"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct GitHubOAuthCallRequest {
#[doc = "The URL the client will redirect to on successful authentication. If empty, no redirect will occur."]
#[serde(rename = "redirectUrl", default, skip_serializing_if = "Option::is_none")]
pub redirect_url: Option<String>,
}
impl GitHubOAuthCallRequest {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "URL used to authorize the Developer Hub GitHub App"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct GitHubOAuthInfoResponse {
#[doc = "URL for authorizing the Developer Hub GitHub App"]
#[serde(rename = "authURL", default, skip_serializing_if = "Option::is_none")]
pub auth_url: Option<String>,
#[doc = "OAuth token used to make calls to GitHub"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub token: Option<String>,
}
impl GitHubOAuthInfoResponse {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The response from List GitHubOAuth operation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct GitHubOAuthListResponse {
#[doc = "Singleton list response containing one GitHubOAuthResponse response"]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<GitHubOAuthResponse>,
}
impl GitHubOAuthListResponse {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The response from List GitHubOAuth operation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct GitHubOAuthProperties {
#[doc = "user making request"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub username: Option<String>,
}
impl GitHubOAuthProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Singleton response of GitHubOAuth containing "]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct GitHubOAuthResponse {
#[serde(flatten)]
pub proxy_resource: ProxyResource,
#[doc = "The response from List GitHubOAuth operation."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<GitHubOAuthProperties>,
}
impl GitHubOAuthResponse {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "GitHub Workflow Profile"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct GitHubWorkflowProfile {
#[doc = "Repository Owner"]
#[serde(rename = "repositoryOwner", default, skip_serializing_if = "Option::is_none")]
pub repository_owner: Option<String>,
#[doc = "Repository Name"]
#[serde(rename = "repositoryName", default, skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[doc = "Repository Branch Name"]
#[serde(rename = "branchName", default, skip_serializing_if = "Option::is_none")]
pub branch_name: Option<String>,
#[doc = "Path to the Dockerfile within the repository."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub dockerfile: Option<String>,
#[doc = "Path to Dockerfile Build Context within the repository."]
#[serde(rename = "dockerBuildContext", default, skip_serializing_if = "Option::is_none")]
pub docker_build_context: Option<String>,
#[serde(rename = "deploymentProperties", default, skip_serializing_if = "Option::is_none")]
pub deployment_properties: Option<DeploymentProperties>,
#[doc = "Kubernetes namespace the application is deployed to."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub namespace: Option<String>,
#[doc = "Information on the azure container registry"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub acr: Option<Acr>,
#[doc = "The fields needed for OIDC with GitHub."]
#[serde(rename = "oidcCredentials", default, skip_serializing_if = "Option::is_none")]
pub oidc_credentials: Option<git_hub_workflow_profile::OidcCredentials>,
#[doc = "The Azure Kubernetes Cluster Resource the application will be deployed to."]
#[serde(rename = "aksResourceId", default, skip_serializing_if = "Option::is_none")]
pub aks_resource_id: Option<String>,
#[doc = "The URL to the Pull Request submitted against the users repository."]
#[serde(rename = "prURL", default, skip_serializing_if = "Option::is_none")]
pub pr_url: Option<String>,
#[doc = "The number associated with the submitted pull request."]
#[serde(rename = "pullNumber", default, skip_serializing_if = "Option::is_none")]
pub pull_number: Option<i32>,
#[doc = "The status of the Pull Request submitted against the users repository."]
#[serde(rename = "prStatus", default, skip_serializing_if = "Option::is_none")]
pub pr_status: Option<PullRequestStatus>,
#[serde(rename = "lastWorkflowRun", default, skip_serializing_if = "Option::is_none")]
pub last_workflow_run: Option<WorkflowRun>,
#[doc = "Determines the authorization status of requests."]
#[serde(rename = "authStatus", default, skip_serializing_if = "Option::is_none")]
pub auth_status: Option<AuthorizationStatus>,
}
impl GitHubWorkflowProfile {
pub fn new() -> Self {
Self::default()
}
}
pub mod git_hub_workflow_profile {
use super::*;
#[doc = "The fields needed for OIDC with GitHub."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OidcCredentials {
#[doc = "Azure Application Client ID"]
#[serde(rename = "azureClientId", default, skip_serializing_if = "Option::is_none")]
pub azure_client_id: Option<String>,
#[doc = "Azure Directory (tenant) ID"]
#[serde(rename = "azureTenantId", default, skip_serializing_if = "Option::is_none")]
pub azure_tenant_id: Option<String>,
}
impl OidcCredentials {
pub fn new() -> Self {
Self::default()
}
}
}
#[doc = "GitHub Profile of a IacProfile."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct IacGitHubProfile {
#[doc = "Repository Name"]
#[serde(rename = "repositoryName", default, skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[doc = "Repository Main Branch"]
#[serde(rename = "repositoryMainBranch", default, skip_serializing_if = "Option::is_none")]
pub repository_main_branch: Option<String>,
#[doc = "Repository Owner"]
#[serde(rename = "repositoryOwner", default, skip_serializing_if = "Option::is_none")]
pub repository_owner: Option<String>,
#[doc = "Determines the authorization status of requests."]
#[serde(rename = "authStatus", default, skip_serializing_if = "Option::is_none")]
pub auth_status: Option<AuthorizationStatus>,
#[doc = "The number associated with the submitted pull request."]
#[serde(rename = "pullNumber", default, skip_serializing_if = "Option::is_none")]
pub pull_number: Option<i32>,
#[doc = "The status of the Pull Request submitted against the users repository."]
#[serde(rename = "prStatus", default, skip_serializing_if = "Option::is_none")]
pub pr_status: Option<PullRequestStatus>,
#[doc = "Repository Branch Name"]
#[serde(rename = "branchName", default, skip_serializing_if = "Option::is_none")]
pub branch_name: Option<String>,
}
impl IacGitHubProfile {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Resource representation of a IacProfile."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct IacProfile {
#[serde(flatten)]
pub tracked_resource: TrackedResource,
#[doc = "Properties of a IacProfile."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<IacProfileProperties>,
#[doc = "A unique read-only string that changes whenever the resource is updated."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub etag: Option<String>,
}
impl IacProfile {
pub fn new(tracked_resource: TrackedResource) -> Self {
Self {
tracked_resource,
properties: None,
etag: None,
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct IacProfileListResult {
#[doc = "The list of IacProfiles."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<IacProfile>,
#[doc = "The URL to the next set of IacProfile results."]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl azure_core::Continuable for IacProfileListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
self.next_link.clone().filter(|value| !value.is_empty())
}
}
impl IacProfileListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Properties of a IacProfile."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct IacProfileProperties {
#[doc = "GitHub Profile of a IacProfile."]
#[serde(rename = "githubProfile", default, skip_serializing_if = "Option::is_none")]
pub github_profile: Option<IacGitHubProfile>,
#[doc = "Terraform backend profile."]
#[serde(rename = "terraformProfile", default, skip_serializing_if = "Option::is_none")]
pub terraform_profile: Option<TerraformProfile>,
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub stages: Vec<StageProperties>,
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub templates: Vec<IacTemplateProperties>,
}
impl IacProfileProperties {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct IacTemplateDetails {
#[doc = "The name of the products."]
#[serde(rename = "productName", default, skip_serializing_if = "Option::is_none")]
pub product_name: Option<String>,
#[doc = "Count of the product"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub count: Option<i32>,
#[doc = "Naming convention of this product"]
#[serde(rename = "namingConvention", default, skip_serializing_if = "Option::is_none")]
pub naming_convention: Option<String>,
}
impl IacTemplateDetails {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Properties of a IacTemplate."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct IacTemplateProperties {
#[doc = "Template Name"]
#[serde(rename = "templateName", default, skip_serializing_if = "Option::is_none")]
pub template_name: Option<String>,
#[doc = "the source store of the template"]
#[serde(rename = "sourceResourceId", default, skip_serializing_if = "Option::is_none")]
pub source_resource_id: Option<String>,
#[doc = "the source stage of the template"]
#[serde(rename = "instanceStage", default, skip_serializing_if = "Option::is_none")]
pub instance_stage: Option<String>,
#[doc = "the sample instance name of the template"]
#[serde(rename = "instanceName", default, skip_serializing_if = "Option::is_none")]
pub instance_name: Option<String>,
#[serde(
rename = "templateDetails",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub template_details: Vec<IacTemplateDetails>,
#[doc = "Determines the authorization status of requests."]
#[serde(rename = "quickStartTemplateType", default, skip_serializing_if = "Option::is_none")]
pub quick_start_template_type: Option<QuickStartTemplateType>,
}
impl IacTemplateProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The mode of generation to be used for generating Manifest."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "ManifestGenerationMode")]
pub enum ManifestGenerationMode {
#[serde(rename = "enabled")]
Enabled,
#[serde(rename = "disabled")]
Disabled,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for ManifestGenerationMode {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for ManifestGenerationMode {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for ManifestGenerationMode {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Enabled => serializer.serialize_unit_variant("ManifestGenerationMode", 0u32, "enabled"),
Self::Disabled => serializer.serialize_unit_variant("ManifestGenerationMode", 1u32, "disabled"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Determines the type of manifests within the repository."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "ManifestType")]
pub enum ManifestType {
#[serde(rename = "helm")]
Helm,
#[serde(rename = "kube")]
Kube,
#[serde(rename = "kustomize")]
Kustomize,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for ManifestType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for ManifestType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for ManifestType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Helm => serializer.serialize_unit_variant("ManifestType", 0u32, "helm"),
Self::Kube => serializer.serialize_unit_variant("ManifestType", 1u32, "kube"),
Self::Kustomize => serializer.serialize_unit_variant("ManifestType", 2u32, "kustomize"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Details of a REST API operation, returned from the Resource Provider Operations API"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Operation {
#[doc = "The name of the operation, as per Resource-Based Access Control (RBAC). Examples: \"Microsoft.Compute/virtualMachines/write\", \"Microsoft.Compute/virtualMachines/capture/action\""]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[doc = "Whether the operation applies to data-plane. This is \"true\" for data-plane operations and \"false\" for ARM/control-plane operations."]
#[serde(rename = "isDataAction", default, skip_serializing_if = "Option::is_none")]
pub is_data_action: Option<bool>,
#[doc = "Localized display information for this particular operation."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub display: Option<operation::Display>,
#[doc = "The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is \"user,system\""]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub origin: Option<operation::Origin>,
#[doc = "Enum. Indicates the action type. \"Internal\" refers to actions that are for internal only APIs."]
#[serde(rename = "actionType", default, skip_serializing_if = "Option::is_none")]
pub action_type: Option<operation::ActionType>,
}
impl Operation {
pub fn new() -> Self {
Self::default()
}
}
pub mod operation {
use super::*;
#[doc = "Localized display information for this particular operation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Display {
#[doc = "The localized friendly form of the resource provider name, e.g. \"Microsoft Monitoring Insights\" or \"Microsoft Compute\"."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub provider: Option<String>,
#[doc = "The localized friendly name of the resource type related to this operation. E.g. \"Virtual Machines\" or \"Job Schedule Collections\"."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub resource: Option<String>,
#[doc = "The concise, localized friendly name for the operation; suitable for dropdowns. E.g. \"Create or Update Virtual Machine\", \"Restart Virtual Machine\"."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub operation: Option<String>,
#[doc = "The short, localized friendly description of the operation; suitable for tool tips and detailed views."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
impl Display {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The intended executor of the operation; as in Resource Based Access Control (RBAC) and audit logs UX. Default value is \"user,system\""]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "Origin")]
pub enum Origin {
#[serde(rename = "user")]
User,
#[serde(rename = "system")]
System,
#[serde(rename = "user,system")]
UserSystem,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for Origin {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for Origin {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for Origin {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::User => serializer.serialize_unit_variant("Origin", 0u32, "user"),
Self::System => serializer.serialize_unit_variant("Origin", 1u32, "system"),
Self::UserSystem => serializer.serialize_unit_variant("Origin", 2u32, "user,system"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Enum. Indicates the action type. \"Internal\" refers to actions that are for internal only APIs."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "ActionType")]
pub enum ActionType {
Internal,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for ActionType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for ActionType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for ActionType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Internal => serializer.serialize_unit_variant("ActionType", 0u32, "Internal"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}
#[doc = "A list of REST API operations supported by an Azure Resource Provider. It contains an URL link to get the next set of results."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct OperationListResult {
#[doc = "List of operations supported by the resource provider"]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<Operation>,
#[doc = "URL to get the next set of operation list results (if there are any)."]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl OperationListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The resource model definition for a Azure Resource Manager proxy resource. It will not have tags and a location"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ProxyResource {
#[serde(flatten)]
pub resource: Resource,
}
impl ProxyResource {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The status of the Pull Request submitted against the users repository."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "PullRequestStatus")]
pub enum PullRequestStatus {
#[serde(rename = "unknown")]
Unknown,
#[serde(rename = "submitted")]
Submitted,
#[serde(rename = "merged")]
Merged,
#[serde(rename = "removed")]
Removed,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for PullRequestStatus {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for PullRequestStatus {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for PullRequestStatus {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Unknown => serializer.serialize_unit_variant("PullRequestStatus", 0u32, "unknown"),
Self::Submitted => serializer.serialize_unit_variant("PullRequestStatus", 1u32, "submitted"),
Self::Merged => serializer.serialize_unit_variant("PullRequestStatus", 2u32, "merged"),
Self::Removed => serializer.serialize_unit_variant("PullRequestStatus", 3u32, "removed"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Determines the authorization status of requests."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "QuickStartTemplateType")]
pub enum QuickStartTemplateType {
None,
#[serde(rename = "HCI")]
Hci,
#[serde(rename = "HCIAKS")]
Hciaks,
#[serde(rename = "HCIARCVM")]
Hciarcvm,
#[serde(rename = "ALL")]
All,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for QuickStartTemplateType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for QuickStartTemplateType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for QuickStartTemplateType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::None => serializer.serialize_unit_variant("QuickStartTemplateType", 0u32, "None"),
Self::Hci => serializer.serialize_unit_variant("QuickStartTemplateType", 1u32, "HCI"),
Self::Hciaks => serializer.serialize_unit_variant("QuickStartTemplateType", 2u32, "HCIAKS"),
Self::Hciarcvm => serializer.serialize_unit_variant("QuickStartTemplateType", 3u32, "HCIARCVM"),
Self::All => serializer.serialize_unit_variant("QuickStartTemplateType", 4u32, "ALL"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "Common fields that are returned in the response for all Azure Resource Manager resources"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct Resource {
#[doc = "Fully qualified resource ID for the resource. E.g. \"/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}\""]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[doc = "The name of the resource"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[doc = "The type of the resource. E.g. \"Microsoft.Compute/virtualMachines\" or \"Microsoft.Storage/storageAccounts\""]
#[serde(rename = "type", default, skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[doc = "Metadata pertaining to creation and last modification of the resource."]
#[serde(rename = "systemData", default, skip_serializing_if = "Option::is_none")]
pub system_data: Option<SystemData>,
}
impl Resource {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ScaleProperty {
#[doc = "The region of the store"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[doc = "The stage of the store"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
#[doc = "Number of the store"]
#[serde(rename = "numberOfStores", default, skip_serializing_if = "Option::is_none")]
pub number_of_stores: Option<i32>,
}
impl ScaleProperty {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct ScaleTemplateRequest {
#[doc = "Template Name"]
#[serde(rename = "templateName", default, skip_serializing_if = "Option::is_none")]
pub template_name: Option<String>,
#[serde(
rename = "scaleProperties",
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub scale_properties: Vec<ScaleProperty>,
}
impl ScaleTemplateRequest {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Properties of a Stage."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct StageProperties {
#[doc = "Stage Name"]
#[serde(rename = "stageName", default, skip_serializing_if = "Option::is_none")]
pub stage_name: Option<String>,
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub dependencies: Vec<String>,
#[serde(rename = "gitEnvironment", default, skip_serializing_if = "Option::is_none")]
pub git_environment: Option<String>,
}
impl StageProperties {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Resource tags."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct TagsObject {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
}
impl TagsObject {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Terraform backend profile."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct TerraformProfile {
#[doc = "Terraform Storage Account Subscription"]
#[serde(rename = "storageAccountSubscription", default, skip_serializing_if = "Option::is_none")]
pub storage_account_subscription: Option<String>,
#[doc = "Terraform Storage Account Resource Group"]
#[serde(rename = "storageAccountResourceGroup", default, skip_serializing_if = "Option::is_none")]
pub storage_account_resource_group: Option<String>,
#[doc = "Terraform Storage Account Name"]
#[serde(rename = "storageAccountName", default, skip_serializing_if = "Option::is_none")]
pub storage_account_name: Option<String>,
#[doc = "Terraform Container Name"]
#[serde(rename = "storageContainerName", default, skip_serializing_if = "Option::is_none")]
pub storage_container_name: Option<String>,
}
impl TerraformProfile {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "The resource model definition for an Azure Resource Manager tracked top level resource which has 'tags' and a 'location'"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct TrackedResource {
#[serde(flatten)]
pub resource: Resource,
#[doc = "Resource tags."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub tags: Option<serde_json::Value>,
#[doc = "The geo-location where the resource lives"]
pub location: String,
}
impl TrackedResource {
pub fn new(location: String) -> Self {
Self {
resource: Resource::default(),
tags: None,
location,
}
}
}
#[doc = "Resource representation of a workflow"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
pub struct Workflow {
#[serde(flatten)]
pub tracked_resource: TrackedResource,
#[doc = "Workflow properties"]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub properties: Option<WorkflowProperties>,
}
impl Workflow {
pub fn new(tracked_resource: TrackedResource) -> Self {
Self {
tracked_resource,
properties: None,
}
}
}
#[doc = "The response from List Workflows operation."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct WorkflowListResult {
#[doc = "The list of workflows."]
#[serde(
default,
deserialize_with = "azure_core::util::deserialize_null_as_default",
skip_serializing_if = "Vec::is_empty"
)]
pub value: Vec<Workflow>,
#[doc = "The URL to the next set of workflow results."]
#[serde(rename = "nextLink", default, skip_serializing_if = "Option::is_none")]
pub next_link: Option<String>,
}
impl azure_core::Continuable for WorkflowListResult {
type Continuation = String;
fn continuation(&self) -> Option<Self::Continuation> {
self.next_link.clone().filter(|value| !value.is_empty())
}
}
impl WorkflowListResult {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Workflow properties"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct WorkflowProperties {
#[doc = "GitHub Workflow Profile"]
#[serde(rename = "githubWorkflowProfile", default, skip_serializing_if = "Option::is_none")]
pub github_workflow_profile: Option<GitHubWorkflowProfile>,
#[doc = "Properties used for generating artifacts such as Dockerfiles and manifests."]
#[serde(rename = "artifactGenerationProperties", default, skip_serializing_if = "Option::is_none")]
pub artifact_generation_properties: Option<ArtifactGenerationProperties>,
}
impl WorkflowProperties {
pub fn new() -> Self {
Self::default()
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct WorkflowRun {
#[doc = "Describes if the workflow run succeeded."]
#[serde(default, skip_serializing_if = "Option::is_none")]
pub succeeded: Option<bool>,
#[doc = "URL to the run of the workflow."]
#[serde(rename = "workflowRunURL", default, skip_serializing_if = "Option::is_none")]
pub workflow_run_url: Option<String>,
#[doc = "The timestamp of the last workflow run."]
#[serde(rename = "lastRunAt", default, with = "azure_core::date::rfc3339::option")]
pub last_run_at: Option<::time::OffsetDateTime>,
#[doc = "Describes the status of the workflow run"]
#[serde(rename = "workflowRunStatus", default, skip_serializing_if = "Option::is_none")]
pub workflow_run_status: Option<WorkflowRunStatus>,
}
impl WorkflowRun {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Describes the status of the workflow run"]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "WorkflowRunStatus")]
pub enum WorkflowRunStatus {
#[serde(rename = "queued")]
Queued,
#[serde(rename = "inprogress")]
Inprogress,
#[serde(rename = "completed")]
Completed,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for WorkflowRunStatus {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for WorkflowRunStatus {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for WorkflowRunStatus {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::Queued => serializer.serialize_unit_variant("WorkflowRunStatus", 0u32, "queued"),
Self::Inprogress => serializer.serialize_unit_variant("WorkflowRunStatus", 1u32, "inprogress"),
Self::Completed => serializer.serialize_unit_variant("WorkflowRunStatus", 2u32, "completed"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct PrLinkResponse {
#[doc = "The link of the pull request."]
#[serde(rename = "prLink", default, skip_serializing_if = "Option::is_none")]
pub pr_link: Option<String>,
}
impl PrLinkResponse {
pub fn new() -> Self {
Self::default()
}
}
#[doc = "Metadata pertaining to creation and last modification of the resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
pub struct SystemData {
#[doc = "The identity that created the resource."]
#[serde(rename = "createdBy", default, skip_serializing_if = "Option::is_none")]
pub created_by: Option<String>,
#[doc = "The type of identity that created the resource."]
#[serde(rename = "createdByType", default, skip_serializing_if = "Option::is_none")]
pub created_by_type: Option<system_data::CreatedByType>,
#[doc = "The timestamp of resource creation (UTC)."]
#[serde(rename = "createdAt", default, with = "azure_core::date::rfc3339::option")]
pub created_at: Option<::time::OffsetDateTime>,
#[doc = "The identity that last modified the resource."]
#[serde(rename = "lastModifiedBy", default, skip_serializing_if = "Option::is_none")]
pub last_modified_by: Option<String>,
#[doc = "The type of identity that last modified the resource."]
#[serde(rename = "lastModifiedByType", default, skip_serializing_if = "Option::is_none")]
pub last_modified_by_type: Option<system_data::LastModifiedByType>,
#[doc = "The timestamp of resource last modification (UTC)"]
#[serde(rename = "lastModifiedAt", default, with = "azure_core::date::rfc3339::option")]
pub last_modified_at: Option<::time::OffsetDateTime>,
}
impl SystemData {
pub fn new() -> Self {
Self::default()
}
}
pub mod system_data {
use super::*;
#[doc = "The type of identity that created the resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "CreatedByType")]
pub enum CreatedByType {
User,
Application,
ManagedIdentity,
Key,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for CreatedByType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for CreatedByType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for CreatedByType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::User => serializer.serialize_unit_variant("CreatedByType", 0u32, "User"),
Self::Application => serializer.serialize_unit_variant("CreatedByType", 1u32, "Application"),
Self::ManagedIdentity => serializer.serialize_unit_variant("CreatedByType", 2u32, "ManagedIdentity"),
Self::Key => serializer.serialize_unit_variant("CreatedByType", 3u32, "Key"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
#[doc = "The type of identity that last modified the resource."]
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
#[serde(remote = "LastModifiedByType")]
pub enum LastModifiedByType {
User,
Application,
ManagedIdentity,
Key,
#[serde(skip_deserializing)]
UnknownValue(String),
}
impl FromStr for LastModifiedByType {
type Err = value::Error;
fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
Self::deserialize(s.into_deserializer())
}
}
impl<'de> Deserialize<'de> for LastModifiedByType {
fn deserialize<D>(deserializer: D) -> std::result::Result<Self, D::Error>
where
D: Deserializer<'de>,
{
let s = String::deserialize(deserializer)?;
let deserialized = Self::from_str(&s).unwrap_or(Self::UnknownValue(s));
Ok(deserialized)
}
}
impl Serialize for LastModifiedByType {
fn serialize<S>(&self, serializer: S) -> std::result::Result<S::Ok, S::Error>
where
S: Serializer,
{
match self {
Self::User => serializer.serialize_unit_variant("LastModifiedByType", 0u32, "User"),
Self::Application => serializer.serialize_unit_variant("LastModifiedByType", 1u32, "Application"),
Self::ManagedIdentity => serializer.serialize_unit_variant("LastModifiedByType", 2u32, "ManagedIdentity"),
Self::Key => serializer.serialize_unit_variant("LastModifiedByType", 3u32, "Key"),
Self::UnknownValue(s) => serializer.serialize_str(s.as_str()),
}
}
}
}