harmont_cloud_raw/

lib.rs

//! GENERATED by `make codegen-sdk-rs` (progenitor). Do not edit by hand.
mod progenitor_client;

#[allow(unused_imports)]
use progenitor_client::{encode_path, ClientHooks, OperationInfo, RequestBuilderExt};
#[allow(unused_imports)]
pub use progenitor_client::{ByteStream, ClientInfo, Error, ResponseValue};
/// Types used as operation parameters and responses.
#[allow(clippy::all)]
pub mod types {
    /// Error types.
    pub mod error {
        /// Error from a `TryFrom` or `FromStr` implementation.
        pub struct ConversionError(::std::borrow::Cow<'static, str>);
        impl ::std::error::Error for ConversionError {}
        impl ::std::fmt::Display for ConversionError {
            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
                ::std::fmt::Display::fmt(&self.0, f)
            }
        }

        impl ::std::fmt::Debug for ConversionError {
            fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> Result<(), ::std::fmt::Error> {
                ::std::fmt::Debug::fmt(&self.0, f)
            }
        }

        impl From<&'static str> for ConversionError {
            fn from(value: &'static str) -> Self {
                Self(value.into())
            }
        }

        impl From<String> for ConversionError {
            fn from(value: String) -> Self {
                Self(value.into())
            }
        }
    }

    ///`AcceptInviteRequest`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "AcceptInviteRequest",
    ///  "type": "object",
    ///  "required": [
    ///    "token"
    ///  ],
    ///  "properties": {
    ///    "token": {
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct AcceptInviteRequest {
        pub token: ::std::string::String,
    }

    ///Requests access to Harmont. Records a sign-up attempt and notifies
    /// admins. Rate-limited per client IP.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "AccessRequestRequest",
    ///  "description": "Requests access to Harmont. Records a sign-up attempt
    /// and notifies admins. Rate-limited per client IP.",
    ///  "examples": [
    ///    {
    ///      "email": "alice@example.com",
    ///      "message": "We'd love to try Harmont for our CI.",
    ///      "name": "Alice"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "email",
    ///    "name"
    ///  ],
    ///  "properties": {
    ///    "email": {
    ///      "description": "The email requesting access.",
    ///      "type": "string"
    ///    },
    ///    "message": {
    ///      "description": "Optional message to the Harmont team (max 2000
    /// characters).",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "name": {
    ///      "description": "The requester's name.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct AccessRequestRequest {
        ///The email requesting access.
        pub email: ::std::string::String,
        ///Optional message to the Harmont team (max 2000 characters).
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub message: ::std::option::Option<::std::string::String>,
        ///The requester's name.
        pub name: ::std::string::String,
    }

    ///A personal API key. The secret is returned only once, at creation.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "ApiToken",
    ///  "description": "A personal API key. The secret is returned only once,
    /// at creation.",
    ///  "type": "object",
    ///  "required": [
    ///    "created_at",
    ///    "id"
    ///  ],
    ///  "properties": {
    ///    "created_at": {
    ///      "description": "When the key was created.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "description": {
    ///      "description": "Human label for the key.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "expires_at": {
    ///      "description": "When the key expires, or null if it never
    /// expires.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "id": {
    ///      "description": "Stable key id.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    },
    ///    "last_used_at": {
    ///      "description": "When the key was last used to authenticate, if
    /// ever.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct ApiToken {
        ///When the key was created.
        pub created_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///Human label for the key.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///When the key expires, or null if it never expires.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub expires_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///Stable key id.
        pub id: ::uuid::Uuid,
        ///When the key was last used to authenticate, if ever.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub last_used_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
    }

    ///Creates a personal API key.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "ApiTokenCreateRequest",
    ///  "description": "Creates a personal API key.",
    ///  "examples": [
    ///    {
    ///      "description": "Laptop CLI",
    ///      "expires_at": null
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "description"
    ///  ],
    ///  "properties": {
    ///    "description": {
    ///      "description": "Human label for the key.",
    ///      "type": "string"
    ///    },
    ///    "expires_at": {
    ///      "description": "Optional expiry; null or omitted means the key
    /// never expires.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct ApiTokenCreateRequest {
        ///Human label for the key.
        pub description: ::std::string::String,
        ///Optional expiry; null or omitted means the key never expires.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub expires_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
    }

    ///The created key and its raw secret. The secret is shown only here, once.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "ApiTokenCreateResponse",
    ///  "description": "The created key and its raw secret. The secret is shown
    /// only here, once.",
    ///  "type": "object",
    ///  "required": [
    ///    "api_token",
    ///    "token"
    ///  ],
    ///  "properties": {
    ///    "api_token": {
    ///      "$ref": "#/components/schemas/ApiToken"
    ///    },
    ///    "token": {
    ///      "description": "The raw API key secret. Store it now; it is never
    /// shown again.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct ApiTokenCreateResponse {
        pub api_token: ApiToken,
        ///The raw API key secret. Store it now; it is never shown again.
        pub token: ::std::string::String,
    }

    ///Every personal API key belonging to the current user.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "ApiTokenListResponse",
    ///  "description": "Every personal API key belonging to the current user.",
    ///  "type": "object",
    ///  "required": [
    ///    "api_tokens"
    ///  ],
    ///  "properties": {
    ///    "api_tokens": {
    ///      "description": "The user's personal API keys.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/ApiToken"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct ApiTokenListResponse {
        ///The user's personal API keys.
        pub api_tokens: ::std::vec::Vec<ApiToken>,
    }

    ///GitHub OAuth callback payload from the SPA.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "AuthGithubRequest",
    ///  "description": "GitHub OAuth callback payload from the SPA.",
    ///  "examples": [
    ///    {
    ///      "code": "abc123def456"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "code"
    ///  ],
    ///  "properties": {
    ///    "code": {
    ///      "description": "The authorization code returned by GitHub to the
    /// SPA.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct AuthGithubRequest {
        ///The authorization code returned by GitHub to the SPA.
        pub code: ::std::string::String,
    }

    ///Google OAuth callback payload from the SPA.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "AuthGoogleRequest",
    ///  "description": "Google OAuth callback payload from the SPA.",
    ///  "examples": [
    ///    {
    ///      "code": "4/0Afg...",
    ///      "redirect_uri": "https://app.harmont.dev/auth/google/callback"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "code",
    ///    "redirect_uri"
    ///  ],
    ///  "properties": {
    ///    "code": {
    ///      "description": "The authorization code returned by Google to the
    /// SPA.",
    ///      "type": "string"
    ///    },
    ///    "redirect_uri": {
    ///      "description": "The redirect URI the SPA used; must match the OAuth
    /// client config.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct AuthGoogleRequest {
        ///The authorization code returned by Google to the SPA.
        pub code: ::std::string::String,
        ///The redirect URI the SPA used; must match the OAuth client config.
        pub redirect_uri: ::std::string::String,
    }

    ///A freshly minted session bearer token and the authenticated user.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "AuthTokenResponse",
    ///  "description": "A freshly minted session bearer token and the
    /// authenticated user.",
    ///  "type": "object",
    ///  "required": [
    ///    "token",
    ///    "user"
    ///  ],
    ///  "properties": {
    ///    "token": {
    ///      "description": "The raw session bearer token. Send it as
    /// `Authorization: Bearer <token>`.",
    ///      "type": "string"
    ///    },
    ///    "user": {
    ///      "$ref": "#/components/schemas/User"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct AuthTokenResponse {
        ///The raw session bearer token. Send it as `Authorization: Bearer
        /// <token>`.
        pub token: ::std::string::String,
        pub user: User,
    }

    ///The organization's current balance — the sum of every ledger entry
    /// (credits positive, debits negative). May be negative.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "BalanceResponse",
    ///  "description": "The organization's current balance — the sum of every
    /// ledger entry (credits positive, debits negative). May be negative.",
    ///  "type": "object",
    ///  "required": [
    ///    "balance_cents"
    ///  ],
    ///  "properties": {
    ///    "balance_cents": {
    ///      "description": "Current balance in cents (credits − debits). May be
    /// negative.",
    ///      "type": "integer"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct BalanceResponse {
        ///Current balance in cents (credits − debits). May be negative.
        pub balance_cents: i64,
    }

    ///One run of a pipeline, identified by its pipeline-scoped number.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "Build",
    ///  "description": "One run of a pipeline, identified by its
    /// pipeline-scoped number.",
    ///  "type": "object",
    ///  "required": [
    ///    "created_at",
    ///    "number",
    ///    "state"
    ///  ],
    ///  "properties": {
    ///    "branch": {
    ///      "description": "Source branch.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "commit": {
    ///      "description": "Source commit SHA.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "created_at": {
    ///      "description": "When the build row was created.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "error_code": {
    ///      "description": "Stable build-level error code, if the build failed
    /// at the build level.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "error_message": {
    ///      "description": "Human-readable build-level error message, if any.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "finished_at": {
    ///      "description": "When the build reached a terminal state.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "message": {
    ///      "description": "Commit/build message.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "number": {
    ///      "description": "The build's number, sequential and unique within
    /// its pipeline.",
    ///      "type": "integer"
    ///    },
    ///    "scheduled_at": {
    ///      "description": "When the build was queued.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "source": {
    ///      "description": "How the build was triggered (e.g. `api`, `webhook`,
    /// `ui`).",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "started_at": {
    ///      "description": "When the build started running.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "state": {
    ///      "description": "The rolled-up build state.",
    ///      "type": "string",
    ///      "enum": [
    ///        "scheduled",
    ///        "running",
    ///        "failing",
    ///        "passed",
    ///        "failed",
    ///        "canceling",
    ///        "canceled"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct Build {
        ///Source branch.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub branch: ::std::option::Option<::std::string::String>,
        ///Source commit SHA.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub commit: ::std::option::Option<::std::string::String>,
        ///When the build row was created.
        pub created_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///Stable build-level error code, if the build failed at the build
        /// level.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub error_code: ::std::option::Option<::std::string::String>,
        ///Human-readable build-level error message, if any.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub error_message: ::std::option::Option<::std::string::String>,
        ///When the build reached a terminal state.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub finished_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///Commit/build message.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub message: ::std::option::Option<::std::string::String>,
        ///The build's number, sequential and unique within its pipeline.
        pub number: i64,
        ///When the build was queued.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub scheduled_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///How the build was triggered (e.g. `api`, `webhook`, `ui`).
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub source: ::std::option::Option<::std::string::String>,
        ///When the build started running.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub started_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///The rolled-up build state.
        pub state: BuildState,
    }

    ///A page of a pipeline's builds (newest first), with an opaque cursor.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "BuildList",
    ///  "description": "A page of a pipeline's builds (newest first), with an
    /// opaque cursor.",
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "next_cursor"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "The builds on this page, newest first.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Build"
    ///      }
    ///    },
    ///    "next_cursor": {
    ///      "description": "Opaque cursor for the next page. Pass it as the
    /// `cursor` query parameter; `null` when there are no more pages.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct BuildList {
        ///The builds on this page, newest first.
        pub data: ::std::vec::Vec<Build>,
        ///Opaque cursor for the next page. Pass it as the `cursor` query
        /// parameter; `null` when there are no more pages.
        pub next_cursor: ::std::option::Option<::std::string::String>,
    }

    ///The rolled-up build state.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "The rolled-up build state.",
    ///  "type": "string",
    ///  "enum": [
    ///    "scheduled",
    ///    "running",
    ///    "failing",
    ///    "passed",
    ///    "failed",
    ///    "canceling",
    ///    "canceled"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum BuildState {
        #[serde(rename = "scheduled")]
        Scheduled,
        #[serde(rename = "running")]
        Running,
        #[serde(rename = "failing")]
        Failing,
        #[serde(rename = "passed")]
        Passed,
        #[serde(rename = "failed")]
        Failed,
        #[serde(rename = "canceling")]
        Canceling,
        #[serde(rename = "canceled")]
        Canceled,
    }

    impl ::std::fmt::Display for BuildState {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Scheduled => f.write_str("scheduled"),
                Self::Running => f.write_str("running"),
                Self::Failing => f.write_str("failing"),
                Self::Passed => f.write_str("passed"),
                Self::Failed => f.write_str("failed"),
                Self::Canceling => f.write_str("canceling"),
                Self::Canceled => f.write_str("canceled"),
            }
        }
    }

    impl ::std::str::FromStr for BuildState {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "scheduled" => Ok(Self::Scheduled),
                "running" => Ok(Self::Running),
                "failing" => Ok(Self::Failing),
                "passed" => Ok(Self::Passed),
                "failed" => Ok(Self::Failed),
                "canceling" => Ok(Self::Canceling),
                "canceled" => Ok(Self::Canceled),
                _ => Err("invalid value".into()),
            }
        }
    }

    impl ::std::convert::TryFrom<&str> for BuildState {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for BuildState {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for BuildState {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    ///Starts a Stripe Checkout Session crediting the organization identified
    /// by the path (`:org`). The body carries only the top-up amount in cents.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CheckoutRequest",
    ///  "description": "Starts a Stripe Checkout Session crediting the
    /// organization identified by the path (`:org`). The body carries only the
    /// top-up amount in cents.",
    ///  "type": "object",
    ///  "required": [
    ///    "amount_cents"
    ///  ],
    ///  "properties": {
    ///    "amount_cents": {
    ///      "description": "The credit top-up amount in cents. Must be a
    /// positive integer within the supported bounds (100–1,000,000).",
    ///      "type": "integer",
    ///      "maximum": 1000000.0,
    ///      "minimum": 100.0
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CheckoutRequest {
        ///The credit top-up amount in cents. Must be a positive integer within
        /// the supported bounds (100–1,000,000).
        pub amount_cents: i64,
    }

    ///The hosted Stripe Checkout URL. Redirect the customer here to complete
    /// the top-up; on success Stripe fires a webhook that posts the matching
    /// credit.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CheckoutResponse",
    ///  "description": "The hosted Stripe Checkout URL. Redirect the customer
    /// here to complete the top-up; on success Stripe fires a webhook that
    /// posts the matching credit.",
    ///  "type": "object",
    ///  "required": [
    ///    "checkout_url"
    ///  ],
    ///  "properties": {
    ///    "checkout_url": {
    ///      "description": "The hosted Stripe Checkout Session URL.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CheckoutResponse {
        ///The hosted Stripe Checkout Session URL.
        pub checkout_url: ::std::string::String,
    }

    ///The CLI polls with its nonce to claim the session token the SPA
    /// transferred.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CliClaimRequest",
    ///  "description": "The CLI polls with its nonce to claim the session token
    /// the SPA transferred.",
    ///  "examples": [
    ///    {
    ///      "nonce": "a7Kp...random"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "nonce"
    ///  ],
    ///  "properties": {
    ///    "nonce": {
    ///      "description": "The nonce the CLI generated for this loopback
    /// handoff.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CliClaimRequest {
        ///The nonce the CLI generated for this loopback handoff.
        pub nonce: ::std::string::String,
    }

    ///A short, human-typeable code the user re-types into the CLI.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CliCodeResponse",
    ///  "description": "A short, human-typeable code the user re-types into the
    /// CLI.",
    ///  "examples": [
    ///    {
    ///      "code": "K7P2QR9MX3WZ4NTV"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "code"
    ///  ],
    ///  "properties": {
    ///    "code": {
    ///      "description": "The single-use paste code. Valid for five
    /// minutes.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CliCodeResponse {
        ///The single-use paste code. Valid for five minutes.
        pub code: ::std::string::String,
    }

    ///The CLI redeems a paste code the user typed in, receiving the session
    /// token.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CliRedeemRequest",
    ///  "description": "The CLI redeems a paste code the user typed in,
    /// receiving the session token.",
    ///  "examples": [
    ///    {
    ///      "code": "K7P2QR9MX3WZ4NTV"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "code"
    ///  ],
    ///  "properties": {
    ///    "code": {
    ///      "description": "The paste code shown by the SPA.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CliRedeemRequest {
        ///The paste code shown by the SPA.
        pub code: ::std::string::String,
    }

    ///The raw session bearer token handed to the CLI.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CliTokenResponse",
    ///  "description": "The raw session bearer token handed to the CLI.",
    ///  "type": "object",
    ///  "required": [
    ///    "token"
    ///  ],
    ///  "properties": {
    ///    "token": {
    ///      "description": "The raw session bearer token. Send it as
    /// `Authorization: Bearer <token>`.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CliTokenResponse {
        ///The raw session bearer token. Send it as `Authorization: Bearer
        /// <token>`.
        pub token: ::std::string::String,
    }

    ///The SPA hands a fresh session token to a locally-running CLI that
    /// generated `nonce` and is polling the claim endpoint.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CliTransferRequest",
    ///  "description": "The SPA hands a fresh session token to a
    /// locally-running CLI that generated `nonce` and is polling the claim
    /// endpoint.",
    ///  "examples": [
    ///    {
    ///      "nonce": "a7Kp...random"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "nonce"
    ///  ],
    ///  "properties": {
    ///    "nonce": {
    ///      "description": "The opaque nonce the CLI generated and is polling
    /// claim with.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CliTransferRequest {
        ///The opaque nonce the CLI generated and is polling claim with.
        pub nonce: ::std::string::String,
    }

    ///Binds an existing GitHub App installation (identified by its GitHub
    /// numeric installation id) to this organization.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "ConnectInstallationRequest",
    ///  "description": "Binds an existing GitHub App installation (identified
    /// by its GitHub numeric installation id) to this organization.",
    ///  "type": "object",
    ///  "required": [
    ///    "installation_id"
    ///  ],
    ///  "properties": {
    ///    "installation_id": {
    ///      "description": "GitHub's numeric installation id to bind.",
    ///      "type": "integer"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct ConnectInstallationRequest {
        ///GitHub's numeric installation id to bind.
        pub installation_id: i64,
    }

    ///Creates a build for a pipeline. Two paths: supply pre-rendered v0 IR
    /// JSON in `pipeline_ir` (the `hm run` / API path), or omit `pipeline_ir`
    /// to have the engine render the registered pipeline's IR in a sandbox VM
    /// (decision #5 — rendering never happens on the API host). The IR is then
    /// parsed and planned in-process; on a plan/render rejection the build row
    /// is created with its error fields set and the request returns 422.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CreateBuildRequest",
    ///  "description": "Creates a build for a pipeline. Two paths: supply
    /// pre-rendered v0 IR JSON in `pipeline_ir` (the `hm run` / API path), or
    /// omit `pipeline_ir` to have the engine render the registered pipeline's
    /// IR in a sandbox VM (decision #5 — rendering never happens on the API
    /// host). The IR is then parsed and planned in-process; on a plan/render
    /// rejection the build row is created with its error fields set and the
    /// request returns 422.",
    ///  "type": "object",
    ///  "required": [
    ///    "branch",
    ///    "commit"
    ///  ],
    ///  "properties": {
    ///    "branch": {
    ///      "description": "Source branch.",
    ///      "type": "string"
    ///    },
    ///    "commit": {
    ///      "description": "Source commit SHA.",
    ///      "type": "string"
    ///    },
    ///    "env": {
    ///      "description": "Build-level environment variables.",
    ///      "type": [
    ///        "object",
    ///        "null"
    ///      ],
    ///      "additionalProperties": {
    ///        "type": "string"
    ///      }
    ///    },
    ///    "message": {
    ///      "description": "Optional build/commit message.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "pipeline_ir": {
    ///      "description": "The pre-rendered v0 IR JSON the engine materialises
    /// into jobs. When absent/blank the engine renders the pipeline's IR in a
    /// sandbox VM instead.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "source": {
    ///      "description": "How the build was triggered (e.g. `api`, `ui`).
    /// Defaults to `api`.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "source_b64": {
    ///      "description": "Base64-encoded source tarball (expected to be
    /// gzipped; the API validates only that it is valid base64, not the archive
    /// format) — the `hm run` local-code upload path. When present, the API
    /// stores it at the build's key and derives the internal,
    /// runner-token-authenticated `source_url`; it takes precedence over any
    /// caller-supplied `source_url`.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "source_sha256": {
    ///      "description": "SHA-256 of the source archive, verified by the
    /// sandbox before rendering (in-sandbox-render path). Defaults to empty
    /// when omitted.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "source_url": {
    ///      "description": "URL to the build's source archive, fetched by the
    /// sandbox. Ignored when `source_b64` is supplied (the API derives this
    /// internally).",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CreateBuildRequest {
        ///Source branch.
        pub branch: ::std::string::String,
        ///Source commit SHA.
        pub commit: ::std::string::String,
        ///Build-level environment variables.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub env: ::std::option::Option<
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
        >,
        ///Optional build/commit message.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub message: ::std::option::Option<::std::string::String>,
        ///The pre-rendered v0 IR JSON the engine materialises into jobs. When
        /// absent/blank the engine renders the pipeline's IR in a sandbox VM
        /// instead.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub pipeline_ir: ::std::option::Option<::std::string::String>,
        ///How the build was triggered (e.g. `api`, `ui`). Defaults to `api`.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub source: ::std::option::Option<::std::string::String>,
        ///Base64-encoded source tarball (expected to be gzipped; the API
        /// validates only that it is valid base64, not the archive format) —
        /// the `hm run` local-code upload path. When present, the API stores it
        /// at the build's key and derives the internal,
        /// runner-token-authenticated `source_url`; it takes precedence over
        /// any caller-supplied `source_url`.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub source_b64: ::std::option::Option<::std::string::String>,
        ///SHA-256 of the source archive, verified by the sandbox before
        /// rendering (in-sandbox-render path). Defaults to empty when omitted.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub source_sha256: ::std::option::Option<::std::string::String>,
        ///URL to the build's source archive, fetched by the sandbox. Ignored
        /// when `source_b64` is supplied (the API derives this internally).
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub source_url: ::std::option::Option<::std::string::String>,
    }

    ///`CreateInviteRequest`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CreateInviteRequest",
    ///  "type": "object",
    ///  "required": [
    ///    "email",
    ///    "role"
    ///  ],
    ///  "properties": {
    ///    "email": {
    ///      "type": "string"
    ///    },
    ///    "role": {
    ///      "type": "string",
    ///      "enum": [
    ///        "admin",
    ///        "member"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CreateInviteRequest {
        pub email: ::std::string::String,
        pub role: CreateInviteRequestRole,
    }

    ///`CreateInviteRequestRole`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "admin",
    ///    "member"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum CreateInviteRequestRole {
        #[serde(rename = "admin")]
        Admin,
        #[serde(rename = "member")]
        Member,
    }

    impl ::std::fmt::Display for CreateInviteRequestRole {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Admin => f.write_str("admin"),
                Self::Member => f.write_str("member"),
            }
        }
    }

    impl ::std::str::FromStr for CreateInviteRequestRole {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "admin" => Ok(Self::Admin),
                "member" => Ok(Self::Member),
                _ => Err("invalid value".into()),
            }
        }
    }

    impl ::std::convert::TryFrom<&str> for CreateInviteRequestRole {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for CreateInviteRequestRole {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for CreateInviteRequestRole {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    ///Create a new organization owned by the authenticated user.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CreateOrganizationRequest",
    ///  "description": "Create a new organization owned by the authenticated
    /// user.",
    ///  "type": "object",
    ///  "required": [
    ///    "name"
    ///  ],
    ///  "properties": {
    ///    "name": {
    ///      "description": "Display name. The slug is derived from this.",
    ///      "type": "string",
    ///      "minLength": 1
    ///    },
    ///    "url": {
    ///      "description": "Optional website URL.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CreateOrganizationRequest {
        ///Display name. The slug is derived from this.
        pub name: CreateOrganizationRequestName,
        ///Optional website URL.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }

    ///Display name. The slug is derived from this.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Display name. The slug is derived from this.",
    ///  "type": "string",
    ///  "minLength": 1
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct CreateOrganizationRequestName(::std::string::String);
    impl ::std::ops::Deref for CreateOrganizationRequestName {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }

    impl ::std::convert::From<CreateOrganizationRequestName> for ::std::string::String {
        fn from(value: CreateOrganizationRequestName) -> Self {
            value.0
        }
    }

    impl ::std::str::FromStr for CreateOrganizationRequestName {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() < 1usize {
                return Err("shorter than 1 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }

    impl ::std::convert::TryFrom<&str> for CreateOrganizationRequestName {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for CreateOrganizationRequestName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for CreateOrganizationRequestName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl<'de> ::serde::Deserialize<'de> for CreateOrganizationRequestName {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }

    ///Creates a pipeline within an organization. The slug is derived from the
    /// name; a slug collision within the organization is rejected.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CreatePipelineRequest",
    ///  "description": "Creates a pipeline within an organization. The slug is
    /// derived from the name; a slug collision within the organization is
    /// rejected.",
    ///  "type": "object",
    ///  "required": [
    ///    "default_branch",
    ///    "name",
    ///    "repository"
    ///  ],
    ///  "properties": {
    ///    "default_branch": {
    ///      "description": "The branch built by default.",
    ///      "type": "string"
    ///    },
    ///    "description": {
    ///      "description": "Optional human description.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "name": {
    ///      "description": "Display name.",
    ///      "type": "string"
    ///    },
    ///    "repository": {
    ///      "description": "The source repository this pipeline builds.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CreatePipelineRequest {
        ///The branch built by default.
        pub default_branch: ::std::string::String,
        ///Optional human description.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Display name.
        pub name: ::std::string::String,
        ///The source repository this pipeline builds.
        pub repository: ::std::string::String,
    }

    ///The authenticated Harmont user and their personal-org slug.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "CurrentUserResponse",
    ///  "description": "The authenticated Harmont user and their personal-org
    /// slug.",
    ///  "type": "object",
    ///  "required": [
    ///    "email",
    ///    "uuid"
    ///  ],
    ///  "properties": {
    ///    "email": {
    ///      "description": "The user's email address.",
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Display name.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "personal_org_slug": {
    ///      "description": "Slug of the user's personal organization.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "uuid": {
    ///      "description": "Stable user id.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct CurrentUserResponse {
        ///The user's email address.
        pub email: ::std::string::String,
        ///Display name.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        ///Slug of the user's personal organization.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub personal_org_slug: ::std::option::Option<::std::string::String>,
        ///Stable user id.
        pub uuid: ::uuid::Uuid,
    }

    ///The Harmont error envelope.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "Error",
    ///  "description": "The Harmont error envelope.",
    ///  "type": "object",
    ///  "required": [
    ///    "error"
    ///  ],
    ///  "properties": {
    ///    "error": {
    ///      "type": "object",
    ///      "required": [
    ///        "code",
    ///        "message",
    ///        "type"
    ///      ],
    ///      "properties": {
    ///        "code": {
    ///          "description": "Catalog code.",
    ///          "type": "string"
    ///        },
    ///        "doc_url": {
    ///          "description": "Docs link for this error.",
    ///          "type": "string"
    ///        },
    ///        "message": {
    ///          "description": "Human-readable message.",
    ///          "type": "string"
    ///        },
    ///        "request_id": {
    ///          "description": "Correlates with server logs/traces.",
    ///          "type": "string"
    ///        },
    ///        "type": {
    ///          "description": "Stable machine error type.",
    ///          "type": "string"
    ///        }
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct Error {
        pub error: ErrorError,
    }

    ///`ErrorError`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "code",
    ///    "message",
    ///    "type"
    ///  ],
    ///  "properties": {
    ///    "code": {
    ///      "description": "Catalog code.",
    ///      "type": "string"
    ///    },
    ///    "doc_url": {
    ///      "description": "Docs link for this error.",
    ///      "type": "string"
    ///    },
    ///    "message": {
    ///      "description": "Human-readable message.",
    ///      "type": "string"
    ///    },
    ///    "request_id": {
    ///      "description": "Correlates with server logs/traces.",
    ///      "type": "string"
    ///    },
    ///    "type": {
    ///      "description": "Stable machine error type.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct ErrorError {
        ///Catalog code.
        pub code: ::std::string::String,
        ///Docs link for this error.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub doc_url: ::std::option::Option<::std::string::String>,
        ///Human-readable message.
        pub message: ::std::string::String,
        ///Correlates with server logs/traces.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub request_id: ::std::option::Option<::std::string::String>,
        ///Stable machine error type.
        #[serde(rename = "type")]
        pub type_: ::std::string::String,
    }

    ///A GitHub App installation the organization has connected. The numeric
    /// `installation_id` is GitHub's installation id (used to address
    /// sync/unbind), while `id` is Harmont's internal row id.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "GithubInstallation",
    ///  "description": "A GitHub App installation the organization has
    /// connected. The numeric `installation_id` is GitHub's installation id
    /// (used to address sync/unbind), while `id` is Harmont's internal row
    /// id.",
    ///  "type": "object",
    ///  "required": [
    ///    "account_login",
    ///    "account_type",
    ///    "created_at",
    ///    "id",
    ///    "installation_id",
    ///    "updated_at"
    ///  ],
    ///  "properties": {
    ///    "account_login": {
    ///      "description": "The GitHub account (org or user) the App is
    /// installed on.",
    ///      "type": "string"
    ///    },
    ///    "account_type": {
    ///      "description": "`Organization` or `User`.",
    ///      "type": "string"
    ///    },
    ///    "created_at": {
    ///      "description": "When the installation row was first mirrored.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "id": {
    ///      "description": "Harmont's internal installation row id.",
    ///      "type": "integer"
    ///    },
    ///    "installation_id": {
    ///      "description": "GitHub's numeric installation id.",
    ///      "type": "integer"
    ///    },
    ///    "updated_at": {
    ///      "description": "When the installation row was last updated.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct GithubInstallation {
        ///The GitHub account (org or user) the App is installed on.
        pub account_login: ::std::string::String,
        ///`Organization` or `User`.
        pub account_type: ::std::string::String,
        ///When the installation row was first mirrored.
        pub created_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///Harmont's internal installation row id.
        pub id: i64,
        ///GitHub's numeric installation id.
        pub installation_id: i64,
        ///When the installation row was last updated.
        pub updated_at: ::chrono::DateTime<::chrono::offset::Utc>,
    }

    ///The organization's connected GitHub App installations.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "GithubInstallationList",
    ///  "description": "The organization's connected GitHub App
    /// installations.",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "The connected installations.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/GithubInstallation"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct GithubInstallationList {
        ///The connected installations.
        pub data: ::std::vec::Vec<GithubInstallation>,
    }

    ///A repository Harmont mirrors from a connected GitHub installation.
    /// `installation_id` is Harmont's internal installation row id (FK), not
    /// GitHub's installation id.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "GithubRepo",
    ///  "description": "A repository Harmont mirrors from a connected GitHub
    /// installation. `installation_id` is Harmont's internal installation row
    /// id (FK), not GitHub's installation id.",
    ///  "type": "object",
    ///  "required": [
    ///    "clone_url",
    ///    "default_branch",
    ///    "full_name",
    ///    "gh_repo_id",
    ///    "id",
    ///    "installation_id",
    ///    "name",
    ///    "owner",
    ///    "private"
    ///  ],
    ///  "properties": {
    ///    "clone_url": {
    ///      "description": "HTTPS clone URL.",
    ///      "type": "string"
    ///    },
    ///    "default_branch": {
    ///      "description": "Default branch name.",
    ///      "type": "string"
    ///    },
    ///    "full_name": {
    ///      "description": "`owner/name` GitHub full name.",
    ///      "type": "string"
    ///    },
    ///    "gh_repo_id": {
    ///      "description": "GitHub's numeric repo id.",
    ///      "type": "integer"
    ///    },
    ///    "id": {
    ///      "description": "Harmont's internal repo row id.",
    ///      "type": "integer"
    ///    },
    ///    "installation_id": {
    ///      "description": "FK onto the internal installation row id.",
    ///      "type": "integer"
    ///    },
    ///    "last_synced_at": {
    ///      "description": "When the repo was last synced from GitHub.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "name": {
    ///      "description": "Short repo name.",
    ///      "type": "string"
    ///    },
    ///    "owner": {
    ///      "description": "GitHub owner login.",
    ///      "type": "string"
    ///    },
    ///    "private": {
    ///      "description": "Whether the repo is private.",
    ///      "type": "boolean"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct GithubRepo {
        ///HTTPS clone URL.
        pub clone_url: ::std::string::String,
        ///Default branch name.
        pub default_branch: ::std::string::String,
        ///`owner/name` GitHub full name.
        pub full_name: ::std::string::String,
        ///GitHub's numeric repo id.
        pub gh_repo_id: i64,
        ///Harmont's internal repo row id.
        pub id: i64,
        ///FK onto the internal installation row id.
        pub installation_id: i64,
        ///When the repo was last synced from GitHub.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub last_synced_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///Short repo name.
        pub name: ::std::string::String,
        ///GitHub owner login.
        pub owner: ::std::string::String,
        ///Whether the repo is private.
        pub private: bool,
    }

    ///Mirrored repositories for an installation or across an organization.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "GithubRepoList",
    ///  "description": "Mirrored repositories for an installation or across an
    /// organization.",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "The mirrored repositories.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/GithubRepo"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct GithubRepoList {
        ///The mirrored repositories.
        pub data: ::std::vec::Vec<GithubRepo>,
    }

    ///`Invite`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "Invite",
    ///  "type": "object",
    ///  "required": [
    ///    "email",
    ///    "expires_at",
    ///    "id",
    ///    "role"
    ///  ],
    ///  "properties": {
    ///    "email": {
    ///      "type": "string"
    ///    },
    ///    "expires_at": {
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "id": {
    ///      "type": "string",
    ///      "format": "uuid"
    ///    },
    ///    "role": {
    ///      "type": "string",
    ///      "enum": [
    ///        "admin",
    ///        "member"
    ///      ]
    ///    },
    ///    "token": {
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct Invite {
        pub email: ::std::string::String,
        pub expires_at: ::chrono::DateTime<::chrono::offset::Utc>,
        pub id: ::uuid::Uuid,
        pub role: InviteRole,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub token: ::std::option::Option<::std::string::String>,
    }

    ///`InviteList`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "InviteList",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Invite"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct InviteList {
        pub data: ::std::vec::Vec<Invite>,
    }

    ///`InviteRole`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "admin",
    ///    "member"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum InviteRole {
        #[serde(rename = "admin")]
        Admin,
        #[serde(rename = "member")]
        Member,
    }

    impl ::std::fmt::Display for InviteRole {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Admin => f.write_str("admin"),
                Self::Member => f.write_str("member"),
            }
        }
    }

    impl ::std::str::FromStr for InviteRole {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "admin" => Ok(Self::Admin),
                "member" => Ok(Self::Member),
                _ => Err("invalid value".into()),
            }
        }
    }

    impl ::std::convert::TryFrom<&str> for InviteRole {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for InviteRole {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for InviteRole {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    ///One job (DAG node) of a build.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "Job",
    ///  "description": "One job (DAG node) of a build.",
    ///  "type": "object",
    ///  "required": [
    ///    "created_at",
    ///    "depends_on",
    ///    "id",
    ///    "soft_failed",
    ///    "state"
    ///  ],
    ///  "properties": {
    ///    "command": {
    ///      "description": "The shell command the job runs.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "created_at": {
    ///      "description": "When the job row was created.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "depends_on": {
    ///      "description": "Ids of this job's prerequisite jobs (its DAG
    /// in-edges), spanning both `depends_on` and `builds_in` dependency kinds.
    /// Empty when the job has no prerequisites.",
    ///      "type": "array",
    ///      "items": {
    ///        "type": "string",
    ///        "format": "uuid"
    ///      }
    ///    },
    ///    "error_code": {
    ///      "description": "Stable job-level error code, if the job failed.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "error_message": {
    ///      "description": "Human-readable job-level error message, if any.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "exit_code": {
    ///      "description": "The command's exit status, once finished.",
    ///      "type": [
    ///        "integer",
    ///        "null"
    ///      ]
    ///    },
    ///    "finished_at": {
    ///      "description": "When the job reached a terminal state.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "id": {
    ///      "description": "The job's id.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    },
    ///    "name": {
    ///      "description": "Human-readable job name.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "retry_policy": {
    ///      "description": "The job's retry policy, if any.",
    ///      "type": [
    ///        "object",
    ///        "null"
    ///      ],
    ///      "additionalProperties": true
    ///    },
    ///    "soft_fail_policy": {
    ///      "description": "The job's soft-fail policy, if any.",
    ///      "type": [
    ///        "object",
    ///        "null"
    ///      ],
    ///      "additionalProperties": true
    ///    },
    ///    "soft_failed": {
    ///      "description": "Whether the job failed but the build was allowed to
    /// continue.",
    ///      "type": "boolean"
    ///    },
    ///    "started_at": {
    ///      "description": "When the job started running.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "state": {
    ///      "description": "The job's FSM state.",
    ///      "type": "string",
    ///      "enum": [
    ///        "pending",
    ///        "scheduled",
    ///        "assigned",
    ///        "running",
    ///        "passed",
    ///        "failed",
    ///        "skipped",
    ///        "canceling",
    ///        "canceled",
    ///        "timing_out",
    ///        "timed_out"
    ///      ]
    ///    },
    ///    "step_key": {
    ///      "description": "The job's stable key within the build's DAG.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct Job {
        ///The shell command the job runs.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub command: ::std::option::Option<::std::string::String>,
        ///When the job row was created.
        pub created_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///Ids of this job's prerequisite jobs (its DAG in-edges), spanning
        /// both `depends_on` and `builds_in` dependency kinds. Empty when the
        /// job has no prerequisites.
        pub depends_on: ::std::vec::Vec<::uuid::Uuid>,
        ///Stable job-level error code, if the job failed.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub error_code: ::std::option::Option<::std::string::String>,
        ///Human-readable job-level error message, if any.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub error_message: ::std::option::Option<::std::string::String>,
        ///The command's exit status, once finished.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub exit_code: ::std::option::Option<i64>,
        ///When the job reached a terminal state.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub finished_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///The job's id.
        pub id: ::uuid::Uuid,
        ///Human-readable job name.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        ///The job's retry policy, if any.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub retry_policy:
            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
        ///The job's soft-fail policy, if any.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub soft_fail_policy:
            ::std::option::Option<::serde_json::Map<::std::string::String, ::serde_json::Value>>,
        ///Whether the job failed but the build was allowed to continue.
        pub soft_failed: bool,
        ///When the job started running.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub started_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///The job's FSM state.
        pub state: JobState,
        ///The job's stable key within the build's DAG.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub step_key: ::std::option::Option<::std::string::String>,
    }

    ///A build's jobs, in DAG creation order.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "JobList",
    ///  "description": "A build's jobs, in DAG creation order.",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "The build's jobs.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Job"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct JobList {
        ///The build's jobs.
        pub data: ::std::vec::Vec<Job>,
    }

    ///The job's FSM state.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "The job's FSM state.",
    ///  "type": "string",
    ///  "enum": [
    ///    "pending",
    ///    "scheduled",
    ///    "assigned",
    ///    "running",
    ///    "passed",
    ///    "failed",
    ///    "skipped",
    ///    "canceling",
    ///    "canceled",
    ///    "timing_out",
    ///    "timed_out"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum JobState {
        #[serde(rename = "pending")]
        Pending,
        #[serde(rename = "scheduled")]
        Scheduled,
        #[serde(rename = "assigned")]
        Assigned,
        #[serde(rename = "running")]
        Running,
        #[serde(rename = "passed")]
        Passed,
        #[serde(rename = "failed")]
        Failed,
        #[serde(rename = "skipped")]
        Skipped,
        #[serde(rename = "canceling")]
        Canceling,
        #[serde(rename = "canceled")]
        Canceled,
        #[serde(rename = "timing_out")]
        TimingOut,
        #[serde(rename = "timed_out")]
        TimedOut,
    }

    impl ::std::fmt::Display for JobState {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Pending => f.write_str("pending"),
                Self::Scheduled => f.write_str("scheduled"),
                Self::Assigned => f.write_str("assigned"),
                Self::Running => f.write_str("running"),
                Self::Passed => f.write_str("passed"),
                Self::Failed => f.write_str("failed"),
                Self::Skipped => f.write_str("skipped"),
                Self::Canceling => f.write_str("canceling"),
                Self::Canceled => f.write_str("canceled"),
                Self::TimingOut => f.write_str("timing_out"),
                Self::TimedOut => f.write_str("timed_out"),
            }
        }
    }

    impl ::std::str::FromStr for JobState {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "pending" => Ok(Self::Pending),
                "scheduled" => Ok(Self::Scheduled),
                "assigned" => Ok(Self::Assigned),
                "running" => Ok(Self::Running),
                "passed" => Ok(Self::Passed),
                "failed" => Ok(Self::Failed),
                "skipped" => Ok(Self::Skipped),
                "canceling" => Ok(Self::Canceling),
                "canceled" => Ok(Self::Canceled),
                "timing_out" => Ok(Self::TimingOut),
                "timed_out" => Ok(Self::TimedOut),
                _ => Err("invalid value".into()),
            }
        }
    }

    impl ::std::convert::TryFrom<&str> for JobState {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for JobState {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for JobState {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    ///A build-scoped HMAC token the SSE log stream accepts, plus its expiry.
    /// Pass the token as the `token` query parameter when opening the log
    /// stream.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "LogTokenResponse",
    ///  "description": "A build-scoped HMAC token the SSE log stream accepts,
    /// plus its expiry. Pass the token as the `token` query parameter when
    /// opening the log stream.",
    ///  "type": "object",
    ///  "required": [
    ///    "expires_at",
    ///    "token"
    ///  ],
    ///  "properties": {
    ///    "expires_at": {
    ///      "description": "When the token expires (~1 hour out).",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "token": {
    ///      "description": "The opaque, build-scoped log token.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct LogTokenResponse {
        ///When the token expires (~1 hour out).
        pub expires_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///The opaque, build-scoped log token.
        pub token: ::std::string::String,
    }

    ///`OrgMember`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "OrgMember",
    ///  "type": "object",
    ///  "required": [
    ///    "email",
    ///    "role",
    ///    "user_uuid"
    ///  ],
    ///  "properties": {
    ///    "email": {
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "role": {
    ///      "type": "string",
    ///      "enum": [
    ///        "owner",
    ///        "admin",
    ///        "member"
    ///      ]
    ///    },
    ///    "user_uuid": {
    ///      "type": "string",
    ///      "format": "uuid"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct OrgMember {
        pub email: ::std::string::String,
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        pub role: OrgMemberRole,
        pub user_uuid: ::uuid::Uuid,
    }

    ///`OrgMemberList`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "OrgMemberList",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/OrgMember"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct OrgMemberList {
        pub data: ::std::vec::Vec<OrgMember>,
    }

    ///`OrgMemberRole`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "owner",
    ///    "admin",
    ///    "member"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum OrgMemberRole {
        #[serde(rename = "owner")]
        Owner,
        #[serde(rename = "admin")]
        Admin,
        #[serde(rename = "member")]
        Member,
    }

    impl ::std::fmt::Display for OrgMemberRole {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Owner => f.write_str("owner"),
                Self::Admin => f.write_str("admin"),
                Self::Member => f.write_str("member"),
            }
        }
    }

    impl ::std::str::FromStr for OrgMemberRole {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "owner" => Ok(Self::Owner),
                "admin" => Ok(Self::Admin),
                "member" => Ok(Self::Member),
                _ => Err("invalid value".into()),
            }
        }
    }

    impl ::std::convert::TryFrom<&str> for OrgMemberRole {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for OrgMemberRole {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for OrgMemberRole {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    ///A Harmont organization the authenticated user is a member of.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "Organization",
    ///  "description": "A Harmont organization the authenticated user is a
    /// member of.",
    ///  "type": "object",
    ///  "required": [
    ///    "created_at",
    ///    "name",
    ///    "slug"
    ///  ],
    ///  "properties": {
    ///    "created_at": {
    ///      "description": "When the organization was created.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "name": {
    ///      "description": "Display name.",
    ///      "type": "string"
    ///    },
    ///    "slug": {
    ///      "description": "URL-safe unique slug identifying the
    /// organization.",
    ///      "type": "string"
    ///    },
    ///    "url": {
    ///      "description": "The organization's website, if set.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct Organization {
        ///When the organization was created.
        pub created_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///Display name.
        pub name: ::std::string::String,
        ///URL-safe unique slug identifying the organization.
        pub slug: ::std::string::String,
        ///The organization's website, if set.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub url: ::std::option::Option<::std::string::String>,
    }

    ///A page of the current user's organizations, with an opaque cursor.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "OrganizationList",
    ///  "description": "A page of the current user's organizations, with an
    /// opaque cursor.",
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "next_cursor"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "The organizations on this page.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Organization"
    ///      }
    ///    },
    ///    "next_cursor": {
    ///      "description": "Opaque cursor for the next page. Pass it as the
    /// `cursor` query parameter; `null` when there are no more pages.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct OrganizationList {
        ///The organizations on this page.
        pub data: ::std::vec::Vec<Organization>,
        ///Opaque cursor for the next page. Pass it as the `cursor` query
        /// parameter; `null` when there are no more pages.
        pub next_cursor: ::std::option::Option<::std::string::String>,
    }

    ///A WebAuthn credential registered to the current user.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "Passkey",
    ///  "description": "A WebAuthn credential registered to the current user.",
    ///  "type": "object",
    ///  "required": [
    ///    "created_at",
    ///    "uuid"
    ///  ],
    ///  "properties": {
    ///    "aaguid": {
    ///      "description": "The authenticator's AAGUID (model identifier), if
    /// reported.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "created_at": {
    ///      "description": "When the passkey was registered.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "last_used_at": {
    ///      "description": "When the passkey was last used to authenticate, if
    /// ever.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "nickname": {
    ///      "description": "Human label for the passkey.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "uuid": {
    ///      "description": "Stable passkey id.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct Passkey {
        ///The authenticator's AAGUID (model identifier), if reported.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub aaguid: ::std::option::Option<::std::string::String>,
        ///When the passkey was registered.
        pub created_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///When the passkey was last used to authenticate, if ever.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub last_used_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///Human label for the passkey.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub nickname: ::std::option::Option<::std::string::String>,
        ///Stable passkey id.
        pub uuid: ::uuid::Uuid,
    }

    ///The server-side challenge id (correlate it on finalize) and the
    /// PublicKeyCredential*Options the browser WebAuthn API consumes.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PasskeyChallengeResponse",
    ///  "description": "The server-side challenge id (correlate it on finalize) and the PublicKeyCredential*Options the browser WebAuthn API consumes.",
    ///  "type": "object",
    ///  "required": [
    ///    "challenge_id",
    ///    "options"
    ///  ],
    ///  "properties": {
    ///    "challenge_id": {
    ///      "description": "Opaque id of the stored, single-use challenge. Echo
    /// it back on finalize.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    },
    ///    "options": {
    ///      "description": "The PublicKeyCredentialCreationOptions /
    /// RequestOptions for the browser.",
    ///      "type": "object",
    ///      "additionalProperties": true
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PasskeyChallengeResponse {
        ///Opaque id of the stored, single-use challenge. Echo it back on
        /// finalize.
        pub challenge_id: ::uuid::Uuid,
        ///The PublicKeyCredentialCreationOptions / RequestOptions for the
        /// browser.
        pub options: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    }

    ///Every passkey registered to the current user.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PasskeyListResponse",
    ///  "description": "Every passkey registered to the current user.",
    ///  "type": "object",
    ///  "required": [
    ///    "passkeys"
    ///  ],
    ///  "properties": {
    ///    "passkeys": {
    ///      "description": "The user's registered passkeys.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Passkey"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PasskeyListResponse {
        ///The user's registered passkeys.
        pub passkeys: ::std::vec::Vec<Passkey>,
    }

    ///Completes passkey login by submitting the assertion for the challenge.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PasskeyLoginFinalizeRequest",
    ///  "description": "Completes passkey login by submitting the assertion for
    /// the challenge.",
    ///  "type": "object",
    ///  "required": [
    ///    "assertion",
    ///    "challenge_id"
    ///  ],
    ///  "properties": {
    ///    "assertion": {
    ///      "description": "The WebAuthn assertion response from
    /// navigator.credentials.get.",
    ///      "type": "object",
    ///      "additionalProperties": true
    ///    },
    ///    "challenge_id": {
    ///      "description": "The challenge id returned by the login-options
    /// call.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PasskeyLoginFinalizeRequest {
        ///The WebAuthn assertion response from navigator.credentials.get.
        pub assertion: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///The challenge id returned by the login-options call.
        pub challenge_id: ::uuid::Uuid,
    }

    ///Starts a discoverable-credential (passkey) login. No fields required.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PasskeyLoginOptionsRequest",
    ///  "description": "Starts a discoverable-credential (passkey) login. No
    /// fields required.",
    ///  "type": "object"
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    #[serde(transparent)]
    pub struct PasskeyLoginOptionsRequest(
        pub ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    );
    impl ::std::ops::Deref for PasskeyLoginOptionsRequest {
        type Target = ::serde_json::Map<::std::string::String, ::serde_json::Value>;
        fn deref(&self) -> &::serde_json::Map<::std::string::String, ::serde_json::Value> {
            &self.0
        }
    }

    impl ::std::convert::From<PasskeyLoginOptionsRequest>
        for ::serde_json::Map<::std::string::String, ::serde_json::Value>
    {
        fn from(value: PasskeyLoginOptionsRequest) -> Self {
            value.0
        }
    }

    impl ::std::convert::From<::serde_json::Map<::std::string::String, ::serde_json::Value>>
        for PasskeyLoginOptionsRequest
    {
        fn from(value: ::serde_json::Map<::std::string::String, ::serde_json::Value>) -> Self {
            Self(value)
        }
    }

    ///Completes adding a passkey by submitting the attestation for the
    /// challenge.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PasskeyRegisterFinalizeRequest",
    ///  "description": "Completes adding a passkey by submitting the
    /// attestation for the challenge.",
    ///  "type": "object",
    ///  "required": [
    ///    "attestation",
    ///    "challenge_id"
    ///  ],
    ///  "properties": {
    ///    "attestation": {
    ///      "description": "The WebAuthn attestation response from
    /// navigator.credentials.create.",
    ///      "type": "object",
    ///      "additionalProperties": true
    ///    },
    ///    "challenge_id": {
    ///      "description": "The challenge id returned by the register-options
    /// call.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    },
    ///    "nickname": {
    ///      "description": "Optional human label for the new passkey.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PasskeyRegisterFinalizeRequest {
        ///The WebAuthn attestation response from navigator.credentials.create.
        pub attestation: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///The challenge id returned by the register-options call.
        pub challenge_id: ::uuid::Uuid,
        ///Optional human label for the new passkey.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub nickname: ::std::option::Option<::std::string::String>,
    }

    ///WebAuthn credential-creation options for adding a passkey to the current
    /// user, plus the server-side challenge id to echo back on finalize.
    /// `excludeCredentials` lists the user's already-registered authenticators.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PasskeyRegisterOptionsResponse",
    ///  "description": "WebAuthn credential-creation options for adding a
    /// passkey to the current user, plus the server-side challenge id to echo
    /// back on finalize. `excludeCredentials` lists the user's
    /// already-registered authenticators.",
    ///  "type": "object",
    ///  "required": [
    ///    "challenge_id",
    ///    "options"
    ///  ],
    ///  "properties": {
    ///    "challenge_id": {
    ///      "description": "Opaque id of the stored, single-use challenge. Echo
    /// it back on finalize.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    },
    ///    "options": {
    ///      "description": "The PublicKeyCredentialCreationOptions for the
    /// browser.",
    ///      "type": "object",
    ///      "additionalProperties": true
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PasskeyRegisterOptionsResponse {
        ///Opaque id of the stored, single-use challenge. Echo it back on
        /// finalize.
        pub challenge_id: ::uuid::Uuid,
        ///The PublicKeyCredentialCreationOptions for the browser.
        pub options: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
    }

    ///Starts passkey sign-up: runs the access gate and emails a verification
    /// link.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PasskeySignupBeginRequest",
    ///  "description": "Starts passkey sign-up: runs the access gate and emails
    /// a verification link.",
    ///  "examples": [
    ///    {
    ///      "email": "alice@harmont.dev",
    ///      "name": "Alice"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "email",
    ///    "name"
    ///  ],
    ///  "properties": {
    ///    "email": {
    ///      "description": "The email to sign up with.",
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "The new user's display name.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PasskeySignupBeginRequest {
        ///The email to sign up with.
        pub email: ::std::string::String,
        ///The new user's display name.
        pub name: ::std::string::String,
    }

    ///Completes passkey sign-up by submitting the attestation for the
    /// challenge.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PasskeySignupFinalizeRequest",
    ///  "description": "Completes passkey sign-up by submitting the attestation
    /// for the challenge.",
    ///  "type": "object",
    ///  "required": [
    ///    "attestation",
    ///    "challenge_id",
    ///    "verification_token"
    ///  ],
    ///  "properties": {
    ///    "attestation": {
    ///      "description": "The WebAuthn attestation response from
    /// navigator.credentials.create.",
    ///      "type": "object",
    ///      "additionalProperties": true
    ///    },
    ///    "challenge_id": {
    ///      "description": "The challenge id returned by the options call.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    },
    ///    "verification_token": {
    ///      "description": "The raw verification token (consumed here).",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PasskeySignupFinalizeRequest {
        ///The WebAuthn attestation response from navigator.credentials.create.
        pub attestation: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///The challenge id returned by the options call.
        pub challenge_id: ::uuid::Uuid,
        ///The raw verification token (consumed here).
        pub verification_token: ::std::string::String,
    }

    ///Exchanges a verification token for WebAuthn credential-creation options.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PasskeySignupOptionsRequest",
    ///  "description": "Exchanges a verification token for WebAuthn
    /// credential-creation options.",
    ///  "type": "object",
    ///  "required": [
    ///    "verification_token"
    ///  ],
    ///  "properties": {
    ///    "verification_token": {
    ///      "description": "The raw token from the verification email.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PasskeySignupOptionsRequest {
        ///The raw token from the verification email.
        pub verification_token: ::std::string::String,
    }

    ///`PingResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "object",
    ///  "required": [
    ///    "status"
    ///  ],
    ///  "properties": {
    ///    "status": {
    ///      "examples": [
    ///        "ok"
    ///      ],
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PingResponse {
        pub status: ::std::string::String,
    }

    ///A repeatable CI workflow belonging to an organization.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "Pipeline",
    ///  "description": "A repeatable CI workflow belonging to an
    /// organization.",
    ///  "type": "object",
    ///  "required": [
    ///    "allow_manual",
    ///    "created_at",
    ///    "default_branch",
    ///    "name",
    ///    "repository",
    ///    "slug",
    ///    "visibility"
    ///  ],
    ///  "properties": {
    ///    "allow_manual": {
    ///      "description": "Whether manual (e.g. `hm run`) builds are
    /// permitted.",
    ///      "type": "boolean"
    ///    },
    ///    "created_at": {
    ///      "description": "When the pipeline was created.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "default_branch": {
    ///      "description": "The branch built by default.",
    ///      "type": "string"
    ///    },
    ///    "description": {
    ///      "description": "Optional human description.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "name": {
    ///      "description": "Display name.",
    ///      "type": "string"
    ///    },
    ///    "repository": {
    ///      "description": "The source repository this pipeline builds.",
    ///      "type": "string"
    ///    },
    ///    "slug": {
    ///      "description": "URL-safe slug, unique within the organization.
    /// Derived from the name.",
    ///      "type": "string"
    ///    },
    ///    "visibility": {
    ///      "description": "Whether the pipeline is private or public.",
    ///      "type": "string",
    ///      "enum": [
    ///        "private",
    ///        "public"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct Pipeline {
        ///Whether manual (e.g. `hm run`) builds are permitted.
        pub allow_manual: bool,
        ///When the pipeline was created.
        pub created_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///The branch built by default.
        pub default_branch: ::std::string::String,
        ///Optional human description.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///Display name.
        pub name: ::std::string::String,
        ///The source repository this pipeline builds.
        pub repository: ::std::string::String,
        ///URL-safe slug, unique within the organization. Derived from the
        /// name.
        pub slug: ::std::string::String,
        ///Whether the pipeline is private or public.
        pub visibility: PipelineVisibility,
    }

    ///A page of an organization's pipelines, with an opaque cursor.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "PipelineList",
    ///  "description": "A page of an organization's pipelines, with an opaque
    /// cursor.",
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "next_cursor"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "The pipelines on this page.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Pipeline"
    ///      }
    ///    },
    ///    "next_cursor": {
    ///      "description": "Opaque cursor for the next page. Pass it as the
    /// `cursor` query parameter; `null` when there are no more pages.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct PipelineList {
        ///The pipelines on this page.
        pub data: ::std::vec::Vec<Pipeline>,
        ///Opaque cursor for the next page. Pass it as the `cursor` query
        /// parameter; `null` when there are no more pages.
        pub next_cursor: ::std::option::Option<::std::string::String>,
    }

    ///Whether the pipeline is private or public.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Whether the pipeline is private or public.",
    ///  "type": "string",
    ///  "enum": [
    ///    "private",
    ///    "public"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum PipelineVisibility {
        #[serde(rename = "private")]
        Private,
        #[serde(rename = "public")]
        Public,
    }

    impl ::std::fmt::Display for PipelineVisibility {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Private => f.write_str("private"),
                Self::Public => f.write_str("public"),
            }
        }
    }

    impl ::std::str::FromStr for PipelineVisibility {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "private" => Ok(Self::Private),
                "public" => Ok(Self::Public),
                _ => Err("invalid value".into()),
            }
        }
    }

    impl ::std::convert::TryFrom<&str> for PipelineVisibility {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for PipelineVisibility {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for PipelineVisibility {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    ///Starts magic-link account recovery. Always 204 (never leaks account
    /// existence).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "RecoverBeginRequest",
    ///  "description": "Starts magic-link account recovery. Always 204 (never
    /// leaks account existence).",
    ///  "examples": [
    ///    {
    ///      "email": "alice@harmont.dev"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "email"
    ///  ],
    ///  "properties": {
    ///    "email": {
    ///      "description": "The email to recover access for.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct RecoverBeginRequest {
        ///The email to recover access for.
        pub email: ::std::string::String,
    }

    ///Completes recovery: consumes the magic-link token + challenge, registers
    /// a new passkey, and mints a session token.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "RecoverFinalizeRequest",
    ///  "description": "Completes recovery: consumes the magic-link token +
    /// challenge, registers a new passkey, and mints a session token.",
    ///  "type": "object",
    ///  "required": [
    ///    "attestation",
    ///    "challenge_id",
    ///    "magic_link_token"
    ///  ],
    ///  "properties": {
    ///    "attestation": {
    ///      "description": "The WebAuthn attestation response from
    /// navigator.credentials.create.",
    ///      "type": "object",
    ///      "additionalProperties": true
    ///    },
    ///    "challenge_id": {
    ///      "description": "The challenge id returned by the recover-options
    /// call.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    },
    ///    "magic_link_token": {
    ///      "description": "The raw recovery token (consumed here).",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct RecoverFinalizeRequest {
        ///The WebAuthn attestation response from navigator.credentials.create.
        pub attestation: ::serde_json::Map<::std::string::String, ::serde_json::Value>,
        ///The challenge id returned by the recover-options call.
        pub challenge_id: ::uuid::Uuid,
        ///The raw recovery token (consumed here).
        pub magic_link_token: ::std::string::String,
    }

    ///Validates a magic-link token (without consuming it) and returns WebAuthn
    /// credential-creation options to enroll a fresh passkey.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "RecoverOptionsRequest",
    ///  "description": "Validates a magic-link token (without consuming it) and
    /// returns WebAuthn credential-creation options to enroll a fresh
    /// passkey.",
    ///  "type": "object",
    ///  "required": [
    ///    "magic_link_token"
    ///  ],
    ///  "properties": {
    ///    "magic_link_token": {
    ///      "description": "The raw token from the recovery email.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct RecoverOptionsRequest {
        ///The raw token from the recovery email.
        pub magic_link_token: ::std::string::String,
    }

    ///Redeems a coupon for the organization identified by the path. The org is
    /// taken from the route (`:org`); the body carries only the coupon code.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "RedeemCouponRequest",
    ///  "description": "Redeems a coupon for the organization identified by the
    /// path. The org is taken from the route (`:org`); the body carries only
    /// the coupon code.",
    ///  "type": "object",
    ///  "required": [
    ///    "code"
    ///  ],
    ///  "properties": {
    ///    "code": {
    ///      "description": "The coupon code to redeem.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct RedeemCouponRequest {
        ///The coupon code to redeem.
        pub code: ::std::string::String,
    }

    ///The credit granted by the coupon and the organization's resulting
    /// balance, both in cents.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "RedeemCouponResponse",
    ///  "description": "The credit granted by the coupon and the organization's
    /// resulting balance, both in cents.",
    ///  "type": "object",
    ///  "required": [
    ///    "balance_cents",
    ///    "credit_cents"
    ///  ],
    ///  "properties": {
    ///    "balance_cents": {
    ///      "description": "The organization's balance after the credit, in
    /// cents.",
    ///      "type": "integer"
    ///    },
    ///    "credit_cents": {
    ///      "description": "The credit granted by the coupon, in cents.",
    ///      "type": "integer"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct RedeemCouponResponse {
        ///The organization's balance after the credit, in cents.
        pub balance_cents: i64,
        ///The credit granted by the coupon, in cents.
        pub credit_cents: i64,
    }

    ///Acknowledges that a Stripe webhook event verified and was recorded
    /// (idempotently). Returned for any verified event — handled or not — so
    /// Stripe stops retrying.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "StripeWebhookResponse",
    ///  "description": "Acknowledges that a Stripe webhook event verified and
    /// was recorded (idempotently). Returned for any verified event — handled
    /// or not — so Stripe stops retrying.",
    ///  "type": "object",
    ///  "required": [
    ///    "status"
    ///  ],
    ///  "properties": {
    ///    "status": {
    ///      "description": "Always `\"ok\"` on a verified, recorded event.",
    ///      "type": "string",
    ///      "enum": [
    ///        "ok"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct StripeWebhookResponse {
        ///Always `"ok"` on a verified, recorded event.
        pub status: StripeWebhookResponseStatus,
    }

    ///Always `"ok"` on a verified, recorded event.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "Always `\"ok\"` on a verified, recorded event.",
    ///  "type": "string",
    ///  "enum": [
    ///    "ok"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum StripeWebhookResponseStatus {
        #[serde(rename = "ok")]
        Ok,
    }

    impl ::std::fmt::Display for StripeWebhookResponseStatus {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Ok => f.write_str("ok"),
            }
        }
    }

    impl ::std::str::FromStr for StripeWebhookResponseStatus {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "ok" => Ok(Self::Ok),
                _ => Err("invalid value".into()),
            }
        }
    }

    impl ::std::convert::TryFrom<&str> for StripeWebhookResponseStatus {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for StripeWebhookResponseStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for StripeWebhookResponseStatus {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    ///A freshly minted session bearer token.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "TokenResponse",
    ///  "description": "A freshly minted session bearer token.",
    ///  "type": "object",
    ///  "required": [
    ///    "token"
    ///  ],
    ///  "properties": {
    ///    "token": {
    ///      "description": "The raw session bearer token. Send it as
    /// `Authorization: Bearer <token>`.",
    ///      "type": "string"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct TokenResponse {
        ///The raw session bearer token. Send it as `Authorization: Bearer
        /// <token>`.
        pub token: ::std::string::String,
    }

    ///One append-only ledger entry — a credit (positive) or debit (negative).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "Transaction",
    ///  "description": "One append-only ledger entry — a credit (positive) or
    /// debit (negative).",
    ///  "type": "object",
    ///  "required": [
    ///    "amount_cents",
    ///    "created_at",
    ///    "id",
    ///    "source"
    ///  ],
    ///  "properties": {
    ///    "amount_cents": {
    ///      "description": "Signed amount in cents: positive for credits,
    /// negative for debits.",
    ///      "type": "integer"
    ///    },
    ///    "created_at": {
    ///      "description": "When the entry was recorded.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "description": {
    ///      "description": "Optional human-readable note.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "id": {
    ///      "description": "The entry's id.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    },
    ///    "source": {
    ///      "description": "What produced the entry.",
    ///      "type": "string",
    ///      "enum": [
    ///        "stripe_topup",
    ///        "coupon_redemption",
    ///        "admin_grant",
    ///        "vm_lease_debit",
    ///        "refund"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct Transaction {
        ///Signed amount in cents: positive for credits, negative for debits.
        pub amount_cents: i64,
        ///When the entry was recorded.
        pub created_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///Optional human-readable note.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub description: ::std::option::Option<::std::string::String>,
        ///The entry's id.
        pub id: ::uuid::Uuid,
        ///What produced the entry.
        pub source: TransactionSource,
    }

    ///A page of an organization's ledger entries (newest first), with an
    /// opaque cursor.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "TransactionList",
    ///  "description": "A page of an organization's ledger entries (newest
    /// first), with an opaque cursor.",
    ///  "type": "object",
    ///  "required": [
    ///    "data",
    ///    "next_cursor"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "description": "The ledger entries on this page, newest first.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/Transaction"
    ///      }
    ///    },
    ///    "next_cursor": {
    ///      "description": "Opaque cursor for the next page. Pass it as the
    /// `cursor` query parameter; `null` when there are no more pages.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct TransactionList {
        ///The ledger entries on this page, newest first.
        pub data: ::std::vec::Vec<Transaction>,
        ///Opaque cursor for the next page. Pass it as the `cursor` query
        /// parameter; `null` when there are no more pages.
        pub next_cursor: ::std::option::Option<::std::string::String>,
    }

    ///What produced the entry.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "What produced the entry.",
    ///  "type": "string",
    ///  "enum": [
    ///    "stripe_topup",
    ///    "coupon_redemption",
    ///    "admin_grant",
    ///    "vm_lease_debit",
    ///    "refund"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum TransactionSource {
        #[serde(rename = "stripe_topup")]
        StripeTopup,
        #[serde(rename = "coupon_redemption")]
        CouponRedemption,
        #[serde(rename = "admin_grant")]
        AdminGrant,
        #[serde(rename = "vm_lease_debit")]
        VmLeaseDebit,
        #[serde(rename = "refund")]
        Refund,
    }

    impl ::std::fmt::Display for TransactionSource {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::StripeTopup => f.write_str("stripe_topup"),
                Self::CouponRedemption => f.write_str("coupon_redemption"),
                Self::AdminGrant => f.write_str("admin_grant"),
                Self::VmLeaseDebit => f.write_str("vm_lease_debit"),
                Self::Refund => f.write_str("refund"),
            }
        }
    }

    impl ::std::str::FromStr for TransactionSource {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "stripe_topup" => Ok(Self::StripeTopup),
                "coupon_redemption" => Ok(Self::CouponRedemption),
                "admin_grant" => Ok(Self::AdminGrant),
                "vm_lease_debit" => Ok(Self::VmLeaseDebit),
                "refund" => Ok(Self::Refund),
                _ => Err("invalid value".into()),
            }
        }
    }

    impl ::std::convert::TryFrom<&str> for TransactionSource {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for TransactionSource {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for TransactionSource {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    ///`UpdateMemberRoleRequest`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "UpdateMemberRoleRequest",
    ///  "type": "object",
    ///  "required": [
    ///    "role"
    ///  ],
    ///  "properties": {
    ///    "role": {
    ///      "type": "string",
    ///      "enum": [
    ///        "owner",
    ///        "admin",
    ///        "member"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct UpdateMemberRoleRequest {
        pub role: UpdateMemberRoleRequestRole,
    }

    ///`UpdateMemberRoleRequestRole`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "type": "string",
    ///  "enum": [
    ///    "owner",
    ///    "admin",
    ///    "member"
    ///  ]
    ///}
    /// ```
    /// </details>
    #[derive(
        :: serde :: Deserialize,
        :: serde :: Serialize,
        Clone,
        Copy,
        Debug,
        Eq,
        Hash,
        Ord,
        PartialEq,
        PartialOrd,
    )]
    pub enum UpdateMemberRoleRequestRole {
        #[serde(rename = "owner")]
        Owner,
        #[serde(rename = "admin")]
        Admin,
        #[serde(rename = "member")]
        Member,
    }

    impl ::std::fmt::Display for UpdateMemberRoleRequestRole {
        fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
            match *self {
                Self::Owner => f.write_str("owner"),
                Self::Admin => f.write_str("admin"),
                Self::Member => f.write_str("member"),
            }
        }
    }

    impl ::std::str::FromStr for UpdateMemberRoleRequestRole {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            match value {
                "owner" => Ok(Self::Owner),
                "admin" => Ok(Self::Admin),
                "member" => Ok(Self::Member),
                _ => Err("invalid value".into()),
            }
        }
    }

    impl ::std::convert::TryFrom<&str> for UpdateMemberRoleRequestRole {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for UpdateMemberRoleRequestRole {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for UpdateMemberRoleRequestRole {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    ///All VM usage attributed to one build, rolled up and broken down per job.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "UsageBreakdownBuild",
    ///  "description": "All VM usage attributed to one build, rolled up and
    /// broken down per job.",
    ///  "type": "object",
    ///  "required": [
    ///    "job_count",
    ///    "jobs",
    ///    "started_at",
    ///    "total_cents"
    ///  ],
    ///  "properties": {
    ///    "build_external_id": {
    ///      "description": "The build's public external id.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "uuid"
    ///    },
    ///    "build_id": {
    ///      "description": "The build's id (null for leases with no build).",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "uuid"
    ///    },
    ///    "build_number": {
    ///      "description": "The per-pipeline build number.",
    ///      "type": [
    ///        "integer",
    ///        "null"
    ///      ]
    ///    },
    ///    "finished_at": {
    ///      "description": "Latest finish among the build's completed leases
    /// (null only if no lease has finished yet).",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "job_count": {
    ///      "description": "Number of job leases in the build.",
    ///      "type": "integer"
    ///    },
    ///    "jobs": {
    ///      "description": "Per-job leases, oldest first.",
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/UsageBreakdownJob"
    ///      }
    ///    },
    ///    "pipeline_id": {
    ///      "description": "The pipeline's id.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "uuid"
    ///    },
    ///    "pipeline_name": {
    ///      "description": "The pipeline's name.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "pipeline_slug": {
    ///      "description": "The pipeline's routing slug (for linking).",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "started_at": {
    ///      "description": "Earliest lease start in the build.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "total_cents": {
    ///      "description": "Sum of this build's lease debits, in cents
    /// (negative).",
    ///      "type": "integer"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct UsageBreakdownBuild {
        ///The build's public external id.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub build_external_id: ::std::option::Option<::uuid::Uuid>,
        ///The build's id (null for leases with no build).
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub build_id: ::std::option::Option<::uuid::Uuid>,
        ///The per-pipeline build number.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub build_number: ::std::option::Option<i64>,
        ///Latest finish among the build's completed leases (null only if no
        /// lease has finished yet).
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub finished_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///Number of job leases in the build.
        pub job_count: i64,
        ///Per-job leases, oldest first.
        pub jobs: ::std::vec::Vec<UsageBreakdownJob>,
        ///The pipeline's id.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub pipeline_id: ::std::option::Option<::uuid::Uuid>,
        ///The pipeline's name.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub pipeline_name: ::std::option::Option<::std::string::String>,
        ///The pipeline's routing slug (for linking).
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub pipeline_slug: ::std::option::Option<::std::string::String>,
        ///Earliest lease start in the build.
        pub started_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///Sum of this build's lease debits, in cents (negative).
        pub total_cents: i64,
    }

    ///A single job's VM lease: the VM that ran it, its shape, how long it ran,
    /// and what it cost.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "UsageBreakdownJob",
    ///  "description": "A single job's VM lease: the VM that ran it, its shape,
    /// how long it ran, and what it cost.",
    ///  "type": "object",
    ///  "required": [
    ///    "amount_cents",
    ///    "cpu_count",
    ///    "disk_gb",
    ///    "memory_gb",
    ///    "started_at"
    ///  ],
    ///  "properties": {
    ///    "amount_cents": {
    ///      "description": "The debit for this lease, in cents (negative).",
    ///      "type": "integer"
    ///    },
    ///    "cpu_count": {
    ///      "description": "vCPUs leased.",
    ///      "type": "integer"
    ///    },
    ///    "disk_gb": {
    ///      "description": "GB of disk leased.",
    ///      "type": "integer"
    ///    },
    ///    "duration_seconds": {
    ///      "description": "Lease duration in seconds (null while still
    /// running).",
    ///      "type": [
    ///        "integer",
    ///        "null"
    ///      ]
    ///    },
    ///    "finished_at": {
    ///      "description": "When the lease finished (null if still running).",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "date-time"
    ///    },
    ///    "job_id": {
    ///      "description": "The job's id.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ],
    ///      "format": "uuid"
    ///    },
    ///    "job_name": {
    ///      "description": "The job's human-readable name.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "memory_gb": {
    ///      "description": "GB of RAM leased.",
    ///      "type": "integer"
    ///    },
    ///    "started_at": {
    ///      "description": "When the lease started.",
    ///      "type": "string",
    ///      "format": "date-time"
    ///    },
    ///    "step_key": {
    ///      "description": "The job's DAG step key.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "vm_handle": {
    ///      "description": "The backend VM identifier that ran the job.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct UsageBreakdownJob {
        ///The debit for this lease, in cents (negative).
        pub amount_cents: i64,
        ///vCPUs leased.
        pub cpu_count: i64,
        ///GB of disk leased.
        pub disk_gb: i64,
        ///Lease duration in seconds (null while still running).
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub duration_seconds: ::std::option::Option<i64>,
        ///When the lease finished (null if still running).
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub finished_at: ::std::option::Option<::chrono::DateTime<::chrono::offset::Utc>>,
        ///The job's id.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub job_id: ::std::option::Option<::uuid::Uuid>,
        ///The job's human-readable name.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub job_name: ::std::option::Option<::std::string::String>,
        ///GB of RAM leased.
        pub memory_gb: i64,
        ///When the lease started.
        pub started_at: ::chrono::DateTime<::chrono::offset::Utc>,
        ///The job's DAG step key.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub step_key: ::std::option::Option<::std::string::String>,
        ///The backend VM identifier that ran the job.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub vm_handle: ::std::option::Option<::std::string::String>,
    }

    ///An organization's VM usage over a window, grouped by build (newest
    /// first).
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "UsageBreakdownResponse",
    ///  "description": "An organization's VM usage over a window, grouped by
    /// build (newest first).",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/UsageBreakdownBuild"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct UsageBreakdownResponse {
        pub data: ::std::vec::Vec<UsageBreakdownBuild>,
    }

    ///Aggregated VM-lease usage for an organization over the requested `[from,
    /// to)` window: resource-seconds per dimension and the total billed cost in
    /// cents.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "UsageResponse",
    ///  "description": "Aggregated VM-lease usage for an organization over the
    /// requested `[from, to)` window: resource-seconds per dimension and the
    /// total billed cost in cents.",
    ///  "type": "object",
    ///  "required": [
    ///    "cpu_seconds",
    ///    "disk_gb_seconds",
    ///    "memory_gb_seconds",
    ///    "total_cents"
    ///  ],
    ///  "properties": {
    ///    "cpu_seconds": {
    ///      "description": "Σ (cpu_count × duration_seconds) over leases in the
    /// window.",
    ///      "type": "integer"
    ///    },
    ///    "disk_gb_seconds": {
    ///      "description": "Σ (disk_gb × duration_seconds) over leases in the
    /// window.",
    ///      "type": "integer"
    ///    },
    ///    "memory_gb_seconds": {
    ///      "description": "Σ (memory_gb × duration_seconds) over leases in the
    /// window.",
    ///      "type": "integer"
    ///    },
    ///    "total_cents": {
    ///      "description": "Σ rate-card cost of the leases in the window, in
    /// cents.",
    ///      "type": "integer"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct UsageResponse {
        ///Σ (cpu_count × duration_seconds) over leases in the window.
        pub cpu_seconds: i64,
        ///Σ (disk_gb × duration_seconds) over leases in the window.
        pub disk_gb_seconds: i64,
        ///Σ (memory_gb × duration_seconds) over leases in the window.
        pub memory_gb_seconds: i64,
        ///Σ rate-card cost of the leases in the window, in cents.
        pub total_cents: i64,
    }

    ///`UsageSeriesBucket`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "UsageSeriesBucket",
    ///  "type": "object",
    ///  "required": [
    ///    "cpu_seconds",
    ///    "date",
    ///    "disk_gb_seconds",
    ///    "memory_gb_seconds",
    ///    "total_cents"
    ///  ],
    ///  "properties": {
    ///    "cpu_seconds": {
    ///      "type": "integer"
    ///    },
    ///    "date": {
    ///      "description": "Bucket day (UTC).",
    ///      "type": "string",
    ///      "format": "date"
    ///    },
    ///    "disk_gb_seconds": {
    ///      "type": "integer"
    ///    },
    ///    "memory_gb_seconds": {
    ///      "type": "integer"
    ///    },
    ///    "total_cents": {
    ///      "description": "Rate-card cost for the day, in cents.",
    ///      "type": "integer"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct UsageSeriesBucket {
        pub cpu_seconds: i64,
        ///Bucket day (UTC).
        pub date: ::chrono::naive::NaiveDate,
        pub disk_gb_seconds: i64,
        pub memory_gb_seconds: i64,
        ///Rate-card cost for the day, in cents.
        pub total_cents: i64,
    }

    ///`UsageSeriesResponse`
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "UsageSeriesResponse",
    ///  "type": "object",
    ///  "required": [
    ///    "data"
    ///  ],
    ///  "properties": {
    ///    "data": {
    ///      "type": "array",
    ///      "items": {
    ///        "$ref": "#/components/schemas/UsageSeriesBucket"
    ///      }
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct UsageSeriesResponse {
        pub data: ::std::vec::Vec<UsageSeriesBucket>,
    }

    ///The authenticated Harmont user.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "User",
    ///  "description": "The authenticated Harmont user.",
    ///  "type": "object",
    ///  "required": [
    ///    "email",
    ///    "uuid"
    ///  ],
    ///  "properties": {
    ///    "email": {
    ///      "description": "The user's email address.",
    ///      "type": "string"
    ///    },
    ///    "name": {
    ///      "description": "Display name.",
    ///      "type": [
    ///        "string",
    ///        "null"
    ///      ]
    ///    },
    ///    "uuid": {
    ///      "description": "Stable user id.",
    ///      "type": "string",
    ///      "format": "uuid"
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct User {
        ///The user's email address.
        pub email: ::std::string::String,
        ///Display name.
        #[serde(default, skip_serializing_if = "::std::option::Option::is_none")]
        pub name: ::std::option::Option<::std::string::String>,
        ///Stable user id.
        pub uuid: ::uuid::Uuid,
    }

    ///Updates the current user's editable profile fields.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "title": "UserUpdateRequest",
    ///  "description": "Updates the current user's editable profile fields.",
    ///  "examples": [
    ///    {
    ///      "name": "Ada Lovelace"
    ///    }
    ///  ],
    ///  "type": "object",
    ///  "required": [
    ///    "name"
    ///  ],
    ///  "properties": {
    ///    "name": {
    ///      "description": "New display name.",
    ///      "type": "string",
    ///      "maxLength": 255,
    ///      "minLength": 1
    ///    }
    ///  }
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Deserialize, :: serde :: Serialize, Clone, Debug)]
    pub struct UserUpdateRequest {
        ///New display name.
        pub name: UserUpdateRequestName,
    }

    ///New display name.
    ///
    /// <details><summary>JSON schema</summary>
    ///
    /// ```json
    ///{
    ///  "description": "New display name.",
    ///  "type": "string",
    ///  "maxLength": 255,
    ///  "minLength": 1
    ///}
    /// ```
    /// </details>
    #[derive(:: serde :: Serialize, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
    #[serde(transparent)]
    pub struct UserUpdateRequestName(::std::string::String);
    impl ::std::ops::Deref for UserUpdateRequestName {
        type Target = ::std::string::String;
        fn deref(&self) -> &::std::string::String {
            &self.0
        }
    }

    impl ::std::convert::From<UserUpdateRequestName> for ::std::string::String {
        fn from(value: UserUpdateRequestName) -> Self {
            value.0
        }
    }

    impl ::std::str::FromStr for UserUpdateRequestName {
        type Err = self::error::ConversionError;
        fn from_str(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            if value.chars().count() > 255usize {
                return Err("longer than 255 characters".into());
            }
            if value.chars().count() < 1usize {
                return Err("shorter than 1 characters".into());
            }
            Ok(Self(value.to_string()))
        }
    }

    impl ::std::convert::TryFrom<&str> for UserUpdateRequestName {
        type Error = self::error::ConversionError;
        fn try_from(value: &str) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<&::std::string::String> for UserUpdateRequestName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: &::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl ::std::convert::TryFrom<::std::string::String> for UserUpdateRequestName {
        type Error = self::error::ConversionError;
        fn try_from(
            value: ::std::string::String,
        ) -> ::std::result::Result<Self, self::error::ConversionError> {
            value.parse()
        }
    }

    impl<'de> ::serde::Deserialize<'de> for UserUpdateRequestName {
        fn deserialize<D>(deserializer: D) -> ::std::result::Result<Self, D::Error>
        where
            D: ::serde::Deserializer<'de>,
        {
            ::std::string::String::deserialize(deserializer)?
                .parse()
                .map_err(|e: self::error::ConversionError| {
                    <D::Error as ::serde::de::Error>::custom(e.to_string())
                })
        }
    }
}

#[derive(Clone, Debug)]
///Client for Harmont API
///
///Harmont's user-facing REST authentication API.
///
///Version: 0
pub struct Client {
    pub(crate) baseurl: String,
    pub(crate) client: reqwest::Client,
}

impl Client {
    /// Create a new client.
    ///
    /// `baseurl` is the base URL provided to the internal
    /// `reqwest::Client`, and should include a scheme and hostname,
    /// as well as port and a path stem if applicable.
    pub fn new(baseurl: &str) -> Self {
        #[cfg(not(target_arch = "wasm32"))]
        let client = {
            let dur = ::std::time::Duration::from_secs(15u64);
            reqwest::ClientBuilder::new()
                .connect_timeout(dur)
                .timeout(dur)
        };
        #[cfg(target_arch = "wasm32")]
        let client = reqwest::ClientBuilder::new();
        Self::new_with_client(baseurl, client.build().unwrap())
    }

    /// Construct a new client with an existing `reqwest::Client`,
    /// allowing more control over its configuration.
    ///
    /// `baseurl` is the base URL provided to the internal
    /// `reqwest::Client`, and should include a scheme and hostname,
    /// as well as port and a path stem if applicable.
    pub fn new_with_client(baseurl: &str, client: reqwest::Client) -> Self {
        Self {
            baseurl: baseurl.to_string(),
            client,
        }
    }
}

impl ClientInfo<()> for Client {
    fn api_version() -> &'static str {
        "0"
    }

    fn baseurl(&self) -> &str {
        self.baseurl.as_str()
    }

    fn client(&self) -> &reqwest::Client {
        &self.client
    }

    fn inner(&self) -> &() {
        &()
    }
}

impl ClientHooks<()> for &Client {}
#[allow(clippy::all)]
impl Client {
    ///Revoke a pending invite
    ///
    ///Sends a `DELETE` request to `/api/v0/organizations/{org}/invites/{id}`
    ///
    ///Arguments:
    /// - `org`:
    /// - `id`:
    pub async fn revoke_invite<'a>(
        &'a self,
        org: &'a str,
        id: &'a str,
    ) -> Result<ResponseValue<()>, Error<()>> {
        let url = format!(
            "{}/api/v0/organizations/{}/invites/{}",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self.client.delete(url).headers(header_map).build()?;
        let info = OperationInfo {
            operation_id: "revoke_invite",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Finalize account recovery
    ///
    ///Consumes the magic link + challenge, registers a fresh passkey, and
    /// returns a session token.
    ///
    ///Sends a `POST` request to `/api/v0/auth/recover/finalize`
    ///
    ///Arguments:
    /// - `body`: Finalize request
    pub async fn recover_finalize<'a>(
        &'a self,
        body: &'a types::RecoverFinalizeRequest,
    ) -> Result<ResponseValue<types::AuthTokenResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/recover/finalize", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "recover_finalize",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Disconnect a GitHub installation from the organization
    ///
    ///Unbinds the installation (by GitHub numeric id) from this organization.
    /// Idempotent: a 204 is returned whether or not the installation was bound
    /// to this organization.
    ///
    ///Sends a `DELETE` request to
    /// `/api/v0/organizations/{org}/github/installations/{id}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `id`: The GitHub numeric installation id.
    pub async fn disconnect_github_installation<'a>(
        &'a self,
        org: &'a str,
        id: i64,
    ) -> Result<ResponseValue<()>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/github/installations/{}",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "disconnect_github_installation",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Claim a transferred session token (CLI loopback poll)
    ///
    ///The CLI polls with the nonce it generated; on a match within the 60s
    /// window it receives the raw session token (single-use).
    ///
    ///Sends a `POST` request to `/api/v0/auth/cli/claim`
    ///
    ///Arguments:
    /// - `body`: Claim request
    pub async fn cli_claim<'a>(
        &'a self,
        body: &'a types::CliClaimRequest,
    ) -> Result<ResponseValue<types::CliTokenResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/cli/claim", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "cli_claim",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List a build's jobs
    ///
    ///Returns the build's jobs in DAG creation order.
    ///
    ///Sends a `GET` request to
    /// `/api/v0/organizations/{org}/pipelines/{pipeline}/builds/{number}/jobs`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `pipeline`: The pipeline slug.
    /// - `number`: The build number.
    pub async fn list_jobs<'a>(
        &'a self,
        org: &'a str,
        pipeline: &'a str,
        number: i64,
    ) -> Result<ResponseValue<types::JobList>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines/{}/builds/{}/jobs",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&pipeline.to_string()),
            encode_path(&number.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_jobs",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List the current user's passkeys
    ///
    ///Sends a `GET` request to `/api/v0/user/passkeys`
    pub async fn list_passkeys<'a>(
        &'a self,
    ) -> Result<ResponseValue<types::PasskeyListResponse>, Error<()>> {
        let url = format!("{}/api/v0/user/passkeys", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_passkeys",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Finalize passkey login
    ///
    ///Verifies the assertion against the resolved credential, advances the
    /// sign-counter, and returns a session token.
    ///
    ///Sends a `POST` request to `/api/v0/auth/passkey/login/finalize`
    ///
    ///Arguments:
    /// - `body`: Login finalize request
    pub async fn passkey_login_finalize<'a>(
        &'a self,
        body: &'a types::PasskeyLoginFinalizeRequest,
    ) -> Result<ResponseValue<types::TokenResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/passkey/login/finalize", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "passkey_login_finalize",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Serve a build's source archive (runner-token auth)
    ///
    ///Streams the gzipped source tarball uploaded for a build to the in-VM
    /// sandbox/agent. Authenticated with the build's runner token via
    /// `Authorization: Bearer <runner_token>` (NOT a session bearer token); the
    /// token is validated against the build's stored hash with a constant-time
    /// compare and is NOT consumed.
    ///
    ///Sends a `GET` request to
    /// `/api/v0/internal/builds/{build_uuid}/source.tar.gz`
    ///
    ///Arguments:
    /// - `build_uuid`: The build's external id (UUID).
    pub async fn get_build_source<'a>(
        &'a self,
        build_uuid: &'a str,
    ) -> Result<ResponseValue<ByteStream>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/internal/builds/{}/source.tar.gz",
            self.baseurl,
            encode_path(&build_uuid.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self.client.get(url).headers(header_map).build()?;
        let info = OperationInfo {
            operation_id: "get_build_source",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => Ok(ResponseValue::stream(response)),
            401u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Sign in with GitHub
    ///
    ///Exchanges a GitHub authorization code for a Harmont session token,
    /// creating the user and their personal org on first sign-in.
    ///
    ///Sends a `POST` request to `/api/v0/auth/github`
    ///
    ///Arguments:
    /// - `body`: GitHub OAuth callback
    pub async fn auth_github<'a>(
        &'a self,
        body: &'a types::AuthGithubRequest,
    ) -> Result<ResponseValue<types::AuthTokenResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/github", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "auth_github",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            403u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            502u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Log out (revoke the current bearer token)
    ///
    ///Revokes the bearer token used for this request. The token can no longer
    /// be used to authenticate. Idempotent.
    ///
    ///Sends a `POST` request to `/api/v0/auth/logout`
    pub async fn logout<'a>(&'a self) -> Result<ResponseValue<()>, Error<()>> {
        let url = format!("{}/api/v0/auth/logout", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self.client.post(url).headers(header_map).build()?;
        let info = OperationInfo {
            operation_id: "logout",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List repositories for a connected installation
    ///
    ///Returns the mirrored repositories for one installation, scoped to this
    /// organization. An installation bound to another organization (or unknown)
    /// yields an empty list.
    ///
    ///Sends a `GET` request to
    /// `/api/v0/organizations/{org}/github/installations/{id}/repos`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `id`: The GitHub numeric installation id.
    pub async fn list_github_installation_repos<'a>(
        &'a self,
        org: &'a str,
        id: i64,
    ) -> Result<ResponseValue<types::GithubRepoList>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/github/installations/{}/repos",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_github_installation_repos",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List connected GitHub installations
    ///
    ///Returns the organization's connected, non-deleted GitHub App
    /// installations.
    ///
    ///Sends a `GET` request to
    /// `/api/v0/organizations/{org}/github/installations`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    pub async fn list_github_installations<'a>(
        &'a self,
        org: &'a str,
    ) -> Result<ResponseValue<types::GithubInstallationList>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/github/installations",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_github_installations",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Connect a GitHub installation to the organization
    ///
    ///Binds an existing GitHub App installation (by GitHub numeric id) to this
    /// organization. The installation must already be mirrored from a prior
    /// `installation.created` webhook. Binding an installation that is
    /// connected to a different organization yields 409; an unknown
    /// installation yields 404.
    ///
    ///Sends a `POST` request to
    /// `/api/v0/organizations/{org}/github/installations`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `body`: The GitHub installation to connect
    pub async fn connect_github_installation<'a>(
        &'a self,
        org: &'a str,
        body: &'a types::ConnectInstallationRequest,
    ) -> Result<ResponseValue<types::GithubInstallation>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/github/installations",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "connect_github_installation",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            201u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            409u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get passkey sign-up creation options
    ///
    ///Validates the verification token and returns WebAuthn
    /// credential-creation options plus the server-side challenge id to echo
    /// back on finalize.
    ///
    ///Sends a `POST` request to `/api/v0/auth/passkey/signup/options`
    ///
    ///Arguments:
    /// - `body`: Options request
    pub async fn passkey_signup_options<'a>(
        &'a self,
        body: &'a types::PasskeySignupOptionsRequest,
    ) -> Result<ResponseValue<types::PasskeyChallengeResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/passkey/signup/options", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "passkey_signup_options",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List organization members
    ///
    ///Sends a `GET` request to `/api/v0/organizations/{org}/members`
    ///
    ///Arguments:
    /// - `org`:
    pub async fn list_org_members<'a>(
        &'a self,
        org: &'a str,
    ) -> Result<ResponseValue<types::OrgMemberList>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/members",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_org_members",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Accept an invite
    ///
    ///Sends a `POST` request to `/api/v0/invites/accept`
    ///
    ///Arguments:
    /// - `body`: Token
    pub async fn accept_invite<'a>(
        &'a self,
        body: &'a types::AcceptInviteRequest,
    ) -> Result<ResponseValue<types::Organization>, Error<types::Error>> {
        let url = format!("{}/api/v0/invites/accept", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "accept_invite",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get options to add a passkey
    ///
    ///Returns WebAuthn credential-creation options for the current user,
    /// excluding their already-registered credentials, plus the challenge id.
    ///
    ///Sends a `POST` request to `/api/v0/auth/passkey/register/options`
    pub async fn passkey_register_options<'a>(
        &'a self,
    ) -> Result<ResponseValue<types::PasskeyRegisterOptionsResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/passkey/register/options", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "passkey_register_options",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            401u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List the current user's API keys
    ///
    ///Sends a `GET` request to `/api/v0/user/api-tokens`
    pub async fn list_api_tokens<'a>(
        &'a self,
    ) -> Result<ResponseValue<types::ApiTokenListResponse>, Error<()>> {
        let url = format!("{}/api/v0/user/api-tokens", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_api_tokens",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Create a personal API key
    ///
    ///Returns the raw secret in the response body. It is shown only once and
    /// cannot be retrieved later.
    ///
    ///Sends a `POST` request to `/api/v0/user/api-tokens`
    ///
    ///Arguments:
    /// - `body`: Create request
    pub async fn create_api_token<'a>(
        &'a self,
        body: &'a types::ApiTokenCreateRequest,
    ) -> Result<ResponseValue<types::ApiTokenCreateResponse>, Error<()>> {
        let url = format!("{}/api/v0/user/api-tokens", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "create_api_token",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            201u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Finalize passkey sign-up
    ///
    ///Verifies the attestation, consumes the verification token, creates the
    /// user + passkey, and returns a session token.
    ///
    ///Sends a `POST` request to `/api/v0/auth/passkey/signup/finalize`
    ///
    ///Arguments:
    /// - `body`: Finalize request
    pub async fn passkey_signup_finalize<'a>(
        &'a self,
        body: &'a types::PasskeySignupFinalizeRequest,
    ) -> Result<ResponseValue<types::AuthTokenResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/passkey/signup/finalize", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "passkey_signup_finalize",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            409u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Hand a session token to a locally-running CLI (loopback)
    ///
    ///Mints a fresh session token for the current user and parks it under the
    /// CLI-supplied nonce for 60 seconds. The CLI claims it via the claim
    /// endpoint.
    ///
    ///Sends a `POST` request to `/api/v0/auth/cli/transfer`
    ///
    ///Arguments:
    /// - `body`: Transfer request
    pub async fn cli_transfer<'a>(
        &'a self,
        body: &'a types::CliTransferRequest,
    ) -> Result<ResponseValue<()>, Error<()>> {
        let url = format!("{}/api/v0/auth/cli/transfer", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "cli_transfer",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List an organization's ledger entries
    ///
    ///Returns the organization's ledger entries, newest first,
    /// cursor-paginated.
    ///
    ///Sends a `GET` request to `/api/v0/billing/transactions/{org}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `cursor`: Opaque cursor from a previous page's `next_cursor`.
    /// - `limit`: Page size (1–100, default 50).
    pub async fn list_billing_transactions<'a>(
        &'a self,
        org: &'a str,
        cursor: Option<&'a str>,
        limit: Option<i64>,
    ) -> Result<ResponseValue<types::TransactionList>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/billing/transactions/{}",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("cursor", &cursor))
            .query(&progenitor_client::QueryParam::new("limit", &limit))
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_billing_transactions",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List a pipeline's builds
    ///
    ///Returns the pipeline's builds, newest first, paginated.
    ///
    ///Sends a `GET` request to
    /// `/api/v0/organizations/{org}/pipelines/{pipeline}/builds`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `pipeline`: The pipeline slug.
    /// - `cursor`: Opaque cursor from a previous page's `next_cursor`.
    /// - `limit`: Page size (1–100, default 50).
    pub async fn list_builds<'a>(
        &'a self,
        org: &'a str,
        pipeline: &'a str,
        cursor: Option<&'a str>,
        limit: Option<i64>,
    ) -> Result<ResponseValue<types::BuildList>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines/{}/builds",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&pipeline.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("cursor", &cursor))
            .query(&progenitor_client::QueryParam::new("limit", &limit))
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_builds",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Create a build
    ///
    ///Creates a build for the pipeline and starts execution in-process. When
    /// `pipeline_ir` is supplied the IR is materialised directly; when it is
    /// absent the engine renders the pipeline's IR in a sandbox VM first
    /// (rendering never happens on the API host). A manual build against a
    /// pipeline that disallows manual builds yields 403; an IR that fails to
    /// render/parse/plan yields 422 (the build row is created with its error
    /// fields set).
    ///
    ///Sends a `POST` request to
    /// `/api/v0/organizations/{org}/pipelines/{pipeline}/builds`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `pipeline`: The pipeline slug.
    /// - `body`: Build attributes
    pub async fn create_build<'a>(
        &'a self,
        org: &'a str,
        pipeline: &'a str,
        body: &'a types::CreateBuildRequest,
    ) -> Result<ResponseValue<types::Build>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines/{}/builds",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&pipeline.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "create_build",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            201u16 => ResponseValue::from_response(response).await,
            402u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            403u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Redeem a CLI paste code for a session token
    ///
    ///The CLI submits the paste code the user typed in; on a match within the
    /// 5m window it receives the raw session token (single-use).
    ///
    ///Sends a `POST` request to `/api/v0/auth/cli/redeem`
    ///
    ///Arguments:
    /// - `body`: Redeem request
    pub async fn cli_redeem<'a>(
        &'a self,
        body: &'a types::CliRedeemRequest,
    ) -> Result<ResponseValue<types::CliTokenResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/cli/redeem", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "cli_redeem",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Mint a build-scoped log token
    ///
    ///Returns a short-lived (~1 hour) HMAC token the SSE log stream accepts,
    /// scoped to this build. Pass it as the stream's `token` query parameter.
    ///
    ///Sends a `GET` request to
    /// `/api/v0/organizations/{org}/pipelines/{pipeline}/builds/{number}/
    /// log-token`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `pipeline`: The pipeline slug.
    /// - `number`: The build number.
    pub async fn get_build_log_token<'a>(
        &'a self,
        org: &'a str,
        pipeline: &'a str,
        number: i64,
    ) -> Result<ResponseValue<types::LogTokenResponse>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines/{}/builds/{}/log-token",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&pipeline.to_string()),
            encode_path(&number.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_build_log_token",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get a job
    ///
    ///Returns a single job within the build. A `job_id` that belongs to
    /// another build is reported as 404.
    ///
    ///Sends a `GET` request to
    /// `/api/v0/organizations/{org}/pipelines/{pipeline}/builds/{number}/jobs/
    /// {job_id}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `pipeline`: The pipeline slug.
    /// - `number`: The build number.
    /// - `job_id`: The job id.
    pub async fn get_job<'a>(
        &'a self,
        org: &'a str,
        pipeline: &'a str,
        number: i64,
        job_id: &'a str,
    ) -> Result<ResponseValue<types::Job>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines/{}/builds/{}/jobs/{}",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&pipeline.to_string()),
            encode_path(&number.to_string()),
            encode_path(&job_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_job",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Sync a connected installation's repositories
    ///
    ///Triggers a live sync: lists the installation's repositories from GitHub
    /// and reconciles the mirror. Returns the installation. The installation
    /// must be connected to this organization.
    ///
    ///Sends a `POST` request to
    /// `/api/v0/organizations/{org}/github/installations/{id}/sync`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `id`: The GitHub numeric installation id.
    pub async fn sync_github_installation<'a>(
        &'a self,
        org: &'a str,
        id: i64,
    ) -> Result<ResponseValue<types::GithubInstallation>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/github/installations/{}/sync",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "sync_github_installation",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            503u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Begin passkey sign-up
    ///
    ///Runs the access gate and emails a verification link. Always returns 204
    /// on the allowed path (never reveals whether the email already has an
    /// account).
    ///
    ///Sends a `POST` request to `/api/v0/auth/passkey/signup/begin`
    ///
    ///Arguments:
    /// - `body`: Sign-up request
    pub async fn passkey_signup_begin<'a>(
        &'a self,
        body: &'a types::PasskeySignupBeginRequest,
    ) -> Result<ResponseValue<()>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/passkey/signup/begin", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "passkey_signup_begin",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            403u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Sign in with Google
    ///
    ///Exchanges a Google authorization code for a Harmont session token,
    /// creating the user and their personal org on first sign-in.
    ///
    ///Sends a `POST` request to `/api/v0/auth/google`
    ///
    ///Arguments:
    /// - `body`: Google OAuth callback
    pub async fn auth_google<'a>(
        &'a self,
        body: &'a types::AuthGoogleRequest,
    ) -> Result<ResponseValue<types::AuthTokenResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/google", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "auth_google",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            403u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            502u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Mint a human-typeable CLI paste code
    ///
    ///Mints a fresh session token for the current user and a short paste code
    /// (valid 5 minutes) the user re-types into the CLI to redeem it.
    ///
    ///Sends a `POST` request to `/api/v0/auth/cli/code`
    pub async fn cli_code<'a>(
        &'a self,
    ) -> Result<ResponseValue<types::CliCodeResponse>, Error<()>> {
        let url = format!("{}/api/v0/auth/cli/code", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "cli_code",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Per-build VM usage breakdown
    ///
    ///Returns the organization's VM usage over the half-open `[from, to)`
    /// window (both ISO-8601), grouped by build (newest first) and broken down
    /// per job lease — pipeline, build number, job, VM handle, resource shape,
    /// duration and cost — so a charge can be traced to its source.
    ///
    ///Sends a `GET` request to `/api/v0/billing/usage/{org}/breakdown`
    ///
    ///Arguments:
    /// - `org`: Organization slug.
    /// - `from`: ISO-8601 window start (inclusive).
    /// - `to`: ISO-8601 window end (exclusive).
    pub async fn get_billing_usage_breakdown<'a>(
        &'a self,
        org: &'a str,
        from: &'a str,
        to: &'a str,
    ) -> Result<ResponseValue<types::UsageBreakdownResponse>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/billing/usage/{}/breakdown",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("from", &from))
            .query(&progenitor_client::QueryParam::new("to", &to))
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_billing_usage_breakdown",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Cancel a build
    ///
    ///Cancels an in-flight build in-process (transitions non-terminal jobs and
    /// tears down their sandboxes). Idempotent: cancelling an already-terminal
    /// build is a no-op. Returns the reloaded build with its updated state.
    ///
    ///Sends a `PUT` request to
    /// `/api/v0/organizations/{org}/pipelines/{pipeline}/builds/{number}/
    /// cancel`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `pipeline`: The pipeline slug.
    /// - `number`: The build number.
    pub async fn cancel_build<'a>(
        &'a self,
        org: &'a str,
        pipeline: &'a str,
        number: i64,
    ) -> Result<ResponseValue<types::Build>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines/{}/builds/{}/cancel",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&pipeline.to_string()),
            encode_path(&number.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .put(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "cancel_build",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List the current user's organizations
    ///
    ///Returns the organizations the authenticated user is a member of,
    /// paginated.
    ///
    ///Sends a `GET` request to `/api/v0/organizations`
    ///
    ///Arguments:
    /// - `cursor`: Opaque cursor from a previous page's `next_cursor`.
    /// - `limit`: Page size (1–100, default 50).
    pub async fn list_organizations<'a>(
        &'a self,
        cursor: Option<&'a str>,
        limit: Option<i64>,
    ) -> Result<ResponseValue<types::OrganizationList>, Error<()>> {
        let url = format!("{}/api/v0/organizations", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("cursor", &cursor))
            .query(&progenitor_client::QueryParam::new("limit", &limit))
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_organizations",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Create an organization
    ///
    ///Creates a new organization with the authenticated user as its owner.
    ///
    ///Sends a `POST` request to `/api/v0/organizations`
    ///
    ///Arguments:
    /// - `body`: Organization to create
    pub async fn create_organization<'a>(
        &'a self,
        body: &'a types::CreateOrganizationRequest,
    ) -> Result<ResponseValue<types::Organization>, Error<types::Error>> {
        let url = format!("{}/api/v0/organizations", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "create_organization",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            201u16 => ResponseValue::from_response(response).await,
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Start a Stripe Checkout Session for a credit top-up
    ///
    ///Creates a Stripe Checkout Session crediting the organization identified
    /// by the path (`:org`) and returns the hosted checkout URL to redirect the
    /// customer to. The body carries only the top-up `amount_cents` (a positive
    /// integer within supported bounds). The credit itself is posted
    /// asynchronously when Stripe fires the matching webhook.
    ///
    ///Sends a `POST` request to `/api/v0/billing/checkout/{org}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `body`: The top-up amount
    pub async fn create_checkout<'a>(
        &'a self,
        org: &'a str,
        body: &'a types::CheckoutRequest,
    ) -> Result<ResponseValue<types::CheckoutResponse>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/billing/checkout/{}",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "create_checkout",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            502u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            503u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List pending invites
    ///
    ///Sends a `GET` request to `/api/v0/organizations/{org}/invites`
    ///
    ///Arguments:
    /// - `org`:
    pub async fn list_invites<'a>(
        &'a self,
        org: &'a str,
    ) -> Result<ResponseValue<types::InviteList>, Error<()>> {
        let url = format!(
            "{}/api/v0/organizations/{}/invites",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_invites",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Invite an email to the organization
    ///
    ///Sends a `POST` request to `/api/v0/organizations/{org}/invites`
    ///
    ///Arguments:
    /// - `org`:
    /// - `body`: Invite
    pub async fn create_invite<'a>(
        &'a self,
        org: &'a str,
        body: &'a types::CreateInviteRequest,
    ) -> Result<ResponseValue<types::Invite>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/invites",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "create_invite",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            201u16 => ResponseValue::from_response(response).await,
            403u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get recovery passkey-creation options
    ///
    ///Validates the magic-link token (without consuming it) and returns
    /// WebAuthn credential-creation options plus the challenge id to echo back
    /// on finalize.
    ///
    ///Sends a `POST` request to `/api/v0/auth/recover/options`
    ///
    ///Arguments:
    /// - `body`: Options request
    pub async fn recover_options<'a>(
        &'a self,
        body: &'a types::RecoverOptionsRequest,
    ) -> Result<ResponseValue<types::PasskeyChallengeResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/recover/options", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "recover_options",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Receive a Stripe webhook event
    ///
    ///Receives a Stripe webhook event and, for `checkout.session.completed`,
    /// posts the matching credit to the organization's ledger and marks the
    /// checkout session complete. **Not** bearer-authenticated: the request is
    /// authenticated by Stripe's `Stripe-Signature` header, verified against
    /// the raw request body and the endpoint's webhook signing secret. Credit
    /// posting is idempotent — replaying the same event id posts the credit
    /// only once. Returns 200 for any verified event (handled or not) so Stripe
    /// stops retrying; a signature failure returns 400.
    ///
    ///Sends a `POST` request to `/api/v0/stripe/webhook`
    pub async fn stripe_webhook<'a>(
        &'a self,
    ) -> Result<ResponseValue<types::StripeWebhookResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/stripe/webhook", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "stripe_webhook",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get the current authenticated user
    ///
    ///Returns the bearer-authenticated user and their personal-organization
    /// slug.
    ///
    ///Sends a `GET` request to `/api/v0/user`
    pub async fn get_current_user<'a>(
        &'a self,
    ) -> Result<ResponseValue<types::CurrentUserResponse>, Error<()>> {
        let url = format!("{}/api/v0/user", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_current_user",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Delete the current user's account
    ///
    ///Sends a `DELETE` request to `/api/v0/user`
    pub async fn delete_current_user<'a>(
        &'a self,
    ) -> Result<ResponseValue<()>, Error<types::Error>> {
        let url = format!("{}/api/v0/user", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "delete_current_user",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            409u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Update the current user's display name
    ///
    ///Sends a `PATCH` request to `/api/v0/user`
    ///
    ///Arguments:
    /// - `body`: Profile update
    pub async fn update_current_user<'a>(
        &'a self,
        body: &'a types::UserUpdateRequest,
    ) -> Result<ResponseValue<types::CurrentUserResponse>, Error<types::Error>> {
        let url = format!("{}/api/v0/user", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .patch(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "update_current_user",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Remove a member
    ///
    ///Sends a `DELETE` request to
    /// `/api/v0/organizations/{org}/members/{user_id}`
    ///
    ///Arguments:
    /// - `org`:
    /// - `user_id`:
    pub async fn remove_org_member<'a>(
        &'a self,
        org: &'a str,
        user_id: &'a str,
    ) -> Result<ResponseValue<()>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/members/{}",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&user_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "remove_org_member",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            403u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            409u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Change a member's role
    ///
    ///Sends a `PATCH` request to
    /// `/api/v0/organizations/{org}/members/{user_id}`
    ///
    ///Arguments:
    /// - `org`:
    /// - `user_id`:
    /// - `body`: New role
    pub async fn update_org_member<'a>(
        &'a self,
        org: &'a str,
        user_id: &'a str,
        body: &'a types::UpdateMemberRoleRequest,
    ) -> Result<ResponseValue<types::OrgMember>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/members/{}",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&user_id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .patch(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "update_org_member",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            403u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            409u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///List an organization's pipelines
    ///
    ///Returns the organization's non-archived pipelines, paginated. A slug the
    /// user cannot access is reported as 404.
    ///
    ///Sends a `GET` request to `/api/v0/organizations/{org}/pipelines`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `cursor`: Opaque cursor from a previous page's `next_cursor`.
    /// - `limit`: Page size (1–100, default 50).
    pub async fn list_pipelines<'a>(
        &'a self,
        org: &'a str,
        cursor: Option<&'a str>,
        limit: Option<i64>,
    ) -> Result<ResponseValue<types::PipelineList>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("cursor", &cursor))
            .query(&progenitor_client::QueryParam::new("limit", &limit))
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "list_pipelines",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Create a pipeline
    ///
    ///Creates a pipeline in the organization. The slug is derived from the
    /// name; a colliding slug within the organization yields 422.
    ///
    ///Sends a `POST` request to `/api/v0/organizations/{org}/pipelines`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `body`: Pipeline attributes
    pub async fn create_pipeline<'a>(
        &'a self,
        org: &'a str,
        body: &'a types::CreatePipelineRequest,
    ) -> Result<ResponseValue<types::Pipeline>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "create_pipeline",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            201u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Liveness probe
    ///
    ///Returns `{"status": "ok"}` if the API is up. No auth required.
    ///
    ///Sends a `GET` request to `/api/v0/ping`
    pub async fn ping<'a>(&'a self) -> Result<ResponseValue<types::PingResponse>, Error<()>> {
        let url = format!("{}/api/v0/ping", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "ping",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Delete one of the current user's passkeys
    ///
    ///Removes the passkey. Refused with 409 `passkey_last_credential` when it
    /// would leave the account with no passkeys. A passkey belonging to another
    /// user is 404.
    ///
    ///Sends a `DELETE` request to `/api/v0/user/passkeys/{uuid}`
    ///
    ///Arguments:
    /// - `uuid`: The passkey id.
    pub async fn delete_passkey<'a>(
        &'a self,
        uuid: &'a str,
    ) -> Result<ResponseValue<()>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/user/passkeys/{}",
            self.baseurl,
            encode_path(&uuid.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "delete_passkey",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            409u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get an organization
    ///
    ///Returns the organization identified by the path slug. A slug that does
    /// not exist or that the user is not a member of is reported as 404.
    ///
    ///Sends a `GET` request to `/api/v0/organizations/{org}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    pub async fn get_organization<'a>(
        &'a self,
        org: &'a str,
    ) -> Result<ResponseValue<types::Organization>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_organization",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Begin account recovery
    ///
    ///Emails a magic-link to the address if it maps to an account. Always
    /// returns 204 (never reveals whether the email has an account).
    ///
    ///Sends a `POST` request to `/api/v0/auth/recover/begin`
    ///
    ///Arguments:
    /// - `body`: Recovery request
    pub async fn recover_begin<'a>(
        &'a self,
        body: &'a types::RecoverBeginRequest,
    ) -> Result<ResponseValue<()>, Error<()>> {
        let url = format!("{}/api/v0/auth/recover/begin", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "recover_begin",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get a build
    ///
    ///Returns the build identified by its pipeline-scoped number. An unknown
    /// number (or one in another pipeline) is reported as 404.
    ///
    ///Sends a `GET` request to
    /// `/api/v0/organizations/{org}/pipelines/{pipeline}/builds/{number}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `pipeline`: The pipeline slug.
    /// - `number`: The build number.
    pub async fn get_build<'a>(
        &'a self,
        org: &'a str,
        pipeline: &'a str,
        number: i64,
    ) -> Result<ResponseValue<types::Build>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines/{}/builds/{}",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&pipeline.to_string()),
            encode_path(&number.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_build",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get an organization's VM usage
    ///
    ///Aggregates the organization's VM-lease usage over the half-open window
    /// `[from, to)` (both ISO-8601 timestamps): resource-seconds per dimension
    /// and the total billed cost in cents. Both `from` and `to` are required.
    ///
    ///Sends a `GET` request to `/api/v0/billing/usage/{org}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `from`: Window start (inclusive), ISO-8601.
    /// - `to`: Window end (exclusive), ISO-8601.
    pub async fn get_billing_usage<'a>(
        &'a self,
        org: &'a str,
        from: &'a str,
        to: &'a str,
    ) -> Result<ResponseValue<types::UsageResponse>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/billing/usage/{}",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("from", &from))
            .query(&progenitor_client::QueryParam::new("to", &to))
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_billing_usage",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get a pipeline
    ///
    ///Returns the pipeline identified by the path slug within the
    /// organization. An unknown slug (or one in another organization) is
    /// reported as 404.
    ///
    ///Sends a `GET` request to
    /// `/api/v0/organizations/{org}/pipelines/{pipeline}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `pipeline`: The pipeline slug.
    pub async fn get_pipeline<'a>(
        &'a self,
        org: &'a str,
        pipeline: &'a str,
    ) -> Result<ResponseValue<types::Pipeline>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/organizations/{}/pipelines/{}",
            self.baseurl,
            encode_path(&org.to_string()),
            encode_path(&pipeline.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_pipeline",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Finalize adding a passkey
    ///
    ///Verifies the attestation against the register challenge and stores the
    /// new passkey for the current user.
    ///
    ///Sends a `POST` request to `/api/v0/auth/passkey/register/finalize`
    ///
    ///Arguments:
    /// - `body`: Finalize request
    pub async fn passkey_register_finalize<'a>(
        &'a self,
        body: &'a types::PasskeyRegisterFinalizeRequest,
    ) -> Result<ResponseValue<types::Passkey>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/passkey/register/finalize", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "passkey_register_finalize",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            401u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            409u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Revoke one of the current user's API keys
    ///
    ///Sends a `DELETE` request to `/api/v0/user/api-tokens/{id}`
    ///
    ///Arguments:
    /// - `id`: The API key id.
    pub async fn revoke_api_token<'a>(
        &'a self,
        id: &'a str,
    ) -> Result<ResponseValue<()>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/user/api-tokens/{}",
            self.baseurl,
            encode_path(&id.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .delete(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "revoke_api_token",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get an organization's balance
    ///
    ///Returns the organization's current balance in cents — the sum of every
    /// ledger entry (credits positive, debits negative). May be negative.
    ///
    ///Sends a `GET` request to `/api/v0/billing/balance/{org}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    pub async fn get_billing_balance<'a>(
        &'a self,
        org: &'a str,
    ) -> Result<ResponseValue<types::BalanceResponse>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/billing/balance/{}",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_billing_balance",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Get passkey login options
    ///
    ///Starts a discoverable-credential login: returns WebAuthn request options
    /// with an empty allow-list plus the server-side challenge id.
    ///
    ///Sends a `POST` request to `/api/v0/auth/passkey/login/options`
    ///
    ///Arguments:
    /// - `body`: Login options request
    pub async fn passkey_login_options<'a>(
        &'a self,
        body: &'a types::PasskeyLoginOptionsRequest,
    ) -> Result<ResponseValue<types::PasskeyChallengeResponse>, Error<()>> {
        let url = format!("{}/api/v0/auth/passkey/login/options", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "passkey_login_options",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Redeem a coupon for an organization
    ///
    ///Redeems a coupon code for the organization identified by the path,
    /// crediting the org and returning the credit and resulting balance. The
    /// org is taken from the route; the body carries only the coupon `code`.
    /// Idempotent per org: a second redemption of the same coupon returns `409
    /// coupon_already_claimed`.
    ///
    ///Sends a `POST` request to `/api/v0/billing/coupon/redeem/{org}`
    ///
    ///Arguments:
    /// - `org`: The organization slug.
    /// - `body`: The coupon to redeem
    pub async fn redeem_coupon<'a>(
        &'a self,
        org: &'a str,
        body: &'a types::RedeemCouponRequest,
    ) -> Result<ResponseValue<types::RedeemCouponResponse>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/billing/coupon/redeem/{}",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "redeem_coupon",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            409u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Request access to Harmont
    ///
    ///Records an access request (a sign-up attempt) and notifies the Harmont
    /// team. Rate-limited per client IP.
    ///
    ///Sends a `POST` request to `/api/v0/auth/access-request`
    ///
    ///Arguments:
    /// - `body`: Access request
    pub async fn access_request<'a>(
        &'a self,
        body: &'a types::AccessRequestRequest,
    ) -> Result<ResponseValue<()>, Error<types::Error>> {
        let url = format!("{}/api/v0/auth/access-request", self.baseurl,);
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .post(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .json(&body)
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "access_request",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            204u16 => Ok(ResponseValue::empty(response)),
            400u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            429u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }

    ///Per-day usage time-series
    ///
    ///Sends a `GET` request to `/api/v0/billing/usage/{org}/series`
    ///
    ///Arguments:
    /// - `org`: Organization slug.
    /// - `from`: ISO-8601 window start (inclusive).
    /// - `to`: ISO-8601 window end (exclusive).
    pub async fn get_billing_usage_series<'a>(
        &'a self,
        org: &'a str,
        from: &'a str,
        to: &'a str,
    ) -> Result<ResponseValue<types::UsageSeriesResponse>, Error<types::Error>> {
        let url = format!(
            "{}/api/v0/billing/usage/{}/series",
            self.baseurl,
            encode_path(&org.to_string()),
        );
        let mut header_map = ::reqwest::header::HeaderMap::with_capacity(1usize);
        header_map.append(
            ::reqwest::header::HeaderName::from_static("api-version"),
            ::reqwest::header::HeaderValue::from_static(Self::api_version()),
        );
        #[allow(unused_mut)]
        let mut request = self
            .client
            .get(url)
            .header(
                ::reqwest::header::ACCEPT,
                ::reqwest::header::HeaderValue::from_static("application/json"),
            )
            .query(&progenitor_client::QueryParam::new("from", &from))
            .query(&progenitor_client::QueryParam::new("to", &to))
            .headers(header_map)
            .build()?;
        let info = OperationInfo {
            operation_id: "get_billing_usage_series",
        };
        self.pre(&mut request, &info).await?;
        let result = self.exec(request, &info).await;
        self.post(&result, &info).await?;
        let response = result?;
        match response.status().as_u16() {
            200u16 => ResponseValue::from_response(response).await,
            404u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            422u16 => Err(Error::ErrorResponse(
                ResponseValue::from_response(response).await?,
            )),
            _ => Err(Error::UnexpectedResponse(response)),
        }
    }
}

/// Items consumers will typically use such as the Client.
pub mod prelude {
    #[allow(unused_imports)]
    pub use super::Client;
}