qcs_api_client_openapi/apis/

reservations_api.rs

// Copyright 2026 Rigetti Computing
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/*
 * Rigetti QCS API
 *
 * # Introduction  This is the documentation for the Rigetti QCS HTTP API.  You can find out more about Rigetti at [https://rigetti.com](https://rigetti.com), and also interact with QCS via the web at [https://qcs.rigetti.com](https://qcs.rigetti.com).  This API is documented in **OpenAPI format** and so is compatible with the dozens of language-specific client generators available [here](https://github.com/OpenAPITools/openapi-generator) and elsewhere on the web.  # Principles  This API follows REST design principles where appropriate, and otherwise an HTTP RPC paradigm. We adhere to the Google [API Improvement Proposals](https://google.aip.dev/general) where reasonable to provide a consistent, intuitive developer experience. HTTP response codes match their specifications, and error messages fit a common format.  # Authentication  All access to the QCS API requires OAuth2 authentication provided by Okta. You can request access [here](https://www.rigetti.com/get-quantum). Once you have a user account, you can download your access token from QCS [here](https://qcs.rigetti.com/auth/token).   That access token is valid for 24 hours after issuance. The value of `access_token` within the JSON file is the token used for authentication (don't use the entire JSON file).  Authenticate requests using the `Authorization` header and a `Bearer` prefix:  ``` curl --header \"Authorization: Bearer eyJraW...Iow\" ```  # Quantum Processor Access  Access to the quantum processors themselves is not yet provided directly by this HTTP API, but is instead performed over ZeroMQ/[rpcq](https://github.com/rigetti/rpcq). Until that changes, we suggest using [pyquil](https://github.com/rigetti/pyquil) to build and execute quantum programs via the Legacy API.  # Legacy API  Our legacy HTTP API remains accessible at https://forest-server.qcs.rigetti.com, and it shares a source of truth with this API's services. You can use either service with the same user account and means of authentication. We strongly recommend using the API documented here, as the legacy API is on the path to deprecation.
 *
 * The version of the OpenAPI document: 2020-07-31
 * Contact: support@rigetti.com
 * Generated by: https://openapi-generator.tech
 */

use super::{ContentType, Error, configuration};
use crate::{apis::ResponseContent, models};
use ::qcs_api_client_common::backoff::{
    ExponentialBackoff, duration_from_io_error, duration_from_reqwest_error, duration_from_response,
};
#[cfg(feature = "tracing")]
use qcs_api_client_common::configuration::tokens::TokenRefresher;
use qcs_dependencies_client::reqwest::{self, StatusCode};
use serde::{Deserialize, Serialize};

#[cfg(feature = "clap")]
#[allow(unused, reason = "not used in all templates, but required in some")]
use ::{miette::IntoDiagnostic as _, qcs_api_client_common::clap_utils::JsonMaybeStdin};

/// Serialize command-line arguments for [`create_reservation`]
#[cfg(feature = "clap")]
#[derive(Debug, clap::Args)]
pub struct CreateReservationClapParams {
    pub create_reservation_request: JsonMaybeStdin<crate::models::CreateReservationRequest>,
    /// Used to specify a subject account ID for a request. Does not take precedence over a corresponding request body field when one is present.
    #[arg(long)]
    pub x_qcs_account_id: Option<String>,
    /// Used to specify the subject account's type for a request in conjunction with the X-QCS-ACCOUNT-ID header. Does not take precedence over a corresponding request body field when one is present.
    #[arg(long)]
    pub x_qcs_account_type: Option<models::AccountType>,
}

#[cfg(feature = "clap")]
impl CreateReservationClapParams {
    pub async fn execute(
        self,
        configuration: &configuration::Configuration,
    ) -> Result<models::Reservation, miette::Error> {
        let request = self.create_reservation_request.into_inner().into_inner();

        create_reservation(
            configuration,
            request,
            self.x_qcs_account_id.as_deref(),
            self.x_qcs_account_type,
        )
        .await
        .into_diagnostic()
    }
}

/// Serialize command-line arguments for [`delete_reservation`]
#[cfg(feature = "clap")]
#[derive(Debug, clap::Args)]
pub struct DeleteReservationClapParams {
    #[arg(long)]
    pub reservation_id: i64,
}

#[cfg(feature = "clap")]
impl DeleteReservationClapParams {
    pub async fn execute(
        self,
        configuration: &configuration::Configuration,
    ) -> Result<models::Reservation, miette::Error> {
        delete_reservation(configuration, self.reservation_id)
            .await
            .into_diagnostic()
    }
}

/// Serialize command-line arguments for [`find_available_reservations`]
#[cfg(feature = "clap")]
#[derive(Debug, clap::Args)]
pub struct FindAvailableReservationsClapParams {
    #[arg(long)]
    pub quantum_processor_id: String,
    #[arg(long)]
    pub start_time_from: String,
    #[arg(long)]
    pub duration: String,
    #[arg(long)]
    pub page_size: Option<i64>,
    /// An opaque token that can be appended to a request query to retrieve the next page of results. Empty if there are no more results to retrieve.
    #[arg(long)]
    pub page_token: Option<String>,
}

#[cfg(feature = "clap")]
impl FindAvailableReservationsClapParams {
    pub async fn execute(
        self,
        configuration: &configuration::Configuration,
    ) -> Result<models::FindAvailableReservationsResponse, miette::Error> {
        find_available_reservations(
            configuration,
            self.quantum_processor_id.as_str(),
            self.start_time_from,
            self.duration.as_str(),
            self.page_size,
            self.page_token.as_deref(),
        )
        .await
        .into_diagnostic()
    }
}

/// Serialize command-line arguments for [`get_quantum_processor_calendar`]
#[cfg(feature = "clap")]
#[derive(Debug, clap::Args)]
pub struct GetQuantumProcessorCalendarClapParams {
    #[arg(long)]
    pub quantum_processor_id: String,
}

#[cfg(feature = "clap")]
impl GetQuantumProcessorCalendarClapParams {
    pub async fn execute(
        self,
        configuration: &configuration::Configuration,
    ) -> Result<models::QuantumProcessorCalendar, miette::Error> {
        get_quantum_processor_calendar(configuration, self.quantum_processor_id.as_str())
            .await
            .into_diagnostic()
    }
}

/// Serialize command-line arguments for [`get_reservation`]
#[cfg(feature = "clap")]
#[derive(Debug, clap::Args)]
pub struct GetReservationClapParams {
    #[arg(long)]
    pub reservation_id: i64,
}

#[cfg(feature = "clap")]
impl GetReservationClapParams {
    pub async fn execute(
        self,
        configuration: &configuration::Configuration,
    ) -> Result<models::Reservation, miette::Error> {
        get_reservation(configuration, self.reservation_id)
            .await
            .into_diagnostic()
    }
}

/// Serialize command-line arguments for [`list_group_reservations`]
#[cfg(feature = "clap")]
#[derive(Debug, clap::Args)]
pub struct ListGroupReservationsClapParams {
    /// URL encoded name of group for which to retrieve reservations.
    #[arg(long)]
    pub group_name: String,
    #[arg(long)]
    pub filter: Option<String>,
    #[arg(long)]
    pub order: Option<String>,
    #[arg(long)]
    pub page_size: Option<i64>,
    /// An opaque token that can be appended to a request query to retrieve the next page of results. Empty if there are no more results to retrieve.
    #[arg(long)]
    pub page_token: Option<String>,
    /// If you wish to include deleted (or cancelled) resources in your response, include `showDeleted=true`.
    #[arg(long)]
    pub show_deleted: Option<String>,
}

#[cfg(feature = "clap")]
impl ListGroupReservationsClapParams {
    pub async fn execute(
        self,
        configuration: &configuration::Configuration,
    ) -> Result<models::ListReservationsResponse, miette::Error> {
        list_group_reservations(
            configuration,
            self.group_name.as_str(),
            self.filter.as_deref(),
            self.order.as_deref(),
            self.page_size,
            self.page_token.as_deref(),
            self.show_deleted.as_deref(),
        )
        .await
        .into_diagnostic()
    }
}

/// Serialize command-line arguments for [`list_reservations`]
#[cfg(feature = "clap")]
#[derive(Debug, clap::Args)]
pub struct ListReservationsClapParams {
    #[arg(long)]
    pub filter: Option<String>,
    #[arg(long)]
    pub order: Option<String>,
    #[arg(long)]
    pub page_size: Option<i64>,
    /// An opaque token that can be appended to a request query to retrieve the next page of results. Empty if there are no more results to retrieve.
    #[arg(long)]
    pub page_token: Option<String>,
    /// If you wish to include deleted (or cancelled) resources in your response, include `showDeleted=true`.
    #[arg(long)]
    pub show_deleted: Option<String>,
    /// Used to specify a subject account ID for a request. Does not take precedence over a corresponding request body field when one is present.
    #[arg(long)]
    pub x_qcs_account_id: Option<String>,
    /// Used to specify the subject account's type for a request in conjunction with the X-QCS-ACCOUNT-ID header. Does not take precedence over a corresponding request body field when one is present.
    #[arg(long)]
    pub x_qcs_account_type: Option<models::AccountType>,
}

#[cfg(feature = "clap")]
impl ListReservationsClapParams {
    pub async fn execute(
        self,
        configuration: &configuration::Configuration,
    ) -> Result<models::ListReservationsResponse, miette::Error> {
        list_reservations(
            configuration,
            self.filter.as_deref(),
            self.order.as_deref(),
            self.page_size,
            self.page_token.as_deref(),
            self.show_deleted.as_deref(),
            self.x_qcs_account_id.as_deref(),
            self.x_qcs_account_type,
        )
        .await
        .into_diagnostic()
    }
}

/// struct for typed errors of method [`create_reservation`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateReservationError {
    Status401(models::Error),
    Status402(models::Error),
    Status403(models::Error),
    Status409(models::Error),
    Status422(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_reservation`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteReservationError {
    Status401(models::Error),
    Status403(models::Error),
    Status404(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`find_available_reservations`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FindAvailableReservationsError {
    Status401(models::Error),
    Status422(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_quantum_processor_calendar`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetQuantumProcessorCalendarError {
    Status403(models::Error),
    Status404(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_reservation`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetReservationError {
    Status401(models::Error),
    Status403(models::Error),
    Status404(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_group_reservations`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListGroupReservationsError {
    Status401(models::Error),
    Status422(models::Error),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_reservations`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListReservationsError {
    Status401(models::Error),
    Status422(models::Error),
    UnknownValue(serde_json::Value),
}

async fn create_reservation_inner(
    configuration: &configuration::Configuration,
    backoff: &mut ExponentialBackoff,
    create_reservation_request: crate::models::CreateReservationRequest,
    x_qcs_account_id: Option<&str>,
    x_qcs_account_type: Option<models::AccountType>,
) -> Result<models::Reservation, Error<CreateReservationError>> {
    let local_var_configuration = configuration;
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_reservation_request = create_reservation_request;
    let p_header_x_qcs_account_id = x_qcs_account_id;
    let p_header_x_qcs_account_type = x_qcs_account_type;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/v1/reservations",
        local_var_configuration.qcs_config.api_url()
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::POST, local_var_uri_str.as_str());

    #[cfg(feature = "tracing")]
    {
        // Ignore parsing errors if the URL is invalid for some reason.
        // If it is invalid, it will turn up as an error later when actually making the request.
        let local_var_do_tracing = local_var_uri_str
            .parse::<::url::Url>()
            .ok()
            .is_none_or(|url| {
                configuration
                    .qcs_config
                    .should_trace(&::urlpattern::UrlPatternMatchInput::Url(url))
            });

        if local_var_do_tracing {
            ::tracing::debug!(
                url=%local_var_uri_str,
                method="POST",
                "making create_reservation request",
            );
        }
    }

    if let Some(local_var_param_value) = p_header_x_qcs_account_id {
        local_var_req_builder =
            local_var_req_builder.header("x-qcs-account-id", local_var_param_value.to_string());
    }
    if let Some(local_var_param_value) = p_header_x_qcs_account_type {
        local_var_req_builder =
            local_var_req_builder.header("x-qcs-account-type", local_var_param_value.to_string());
    }

    // Use the QCS Bearer token if a client OAuthSession is present,
    // but do not require one when the security schema says it is optional.
    {
        use qcs_api_client_common::configuration::TokenError;

        #[allow(
            clippy::nonminimal_bool,
            clippy::eq_op,
            reason = "Logic must be done at runtime since it cannot be handled by the mustache template engine."
        )]
        let is_jwt_bearer_optional: bool = false || "JWTBearer" == "JWTBearerOptional";

        let token = local_var_configuration
            .qcs_config
            .get_bearer_access_token()
            .await;

        if is_jwt_bearer_optional && matches!(token, Err(TokenError::NoCredentials)) {
            // the client is configured without any OAuthSession, but this call does not require one.
            #[cfg(feature = "tracing")]
            tracing::debug!(
                "No client credentials found, but this call does not require authentication."
            );
        } else {
            local_var_req_builder = local_var_req_builder.bearer_auth(token?.secret());
        }
    }

    local_var_req_builder = local_var_req_builder.json(&p_body_create_reservation_request);

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_raw_content_type = local_var_resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream")
        .to_string();
    let local_var_content_type = super::ContentType::from(local_var_raw_content_type.as_str());

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        let local_var_content = local_var_resp.text().await?;
        match local_var_content_type {
            ContentType::Json => serde_path_to_error::deserialize(
                &mut serde_json::Deserializer::from_str(&local_var_content),
            )
            .map_err(Error::from),
            ContentType::Text => Err(Error::InvalidContentType {
                content_type: local_var_raw_content_type,
                return_type: "models::Reservation",
            }),
            ContentType::Unsupported(unknown_type) => Err(Error::InvalidContentType {
                content_type: unknown_type,
                return_type: "models::Reservation",
            }),
        }
    } else {
        let local_var_retry_delay =
            duration_from_response(local_var_resp.status(), local_var_resp.headers(), backoff);
        let local_var_content = local_var_resp.text().await?;
        let local_var_entity: Option<CreateReservationError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
            retry_delay: local_var_retry_delay,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// Create a new reservation.  The following precedence applies when specifying the reservation subject account ID and type: * request body `accountId` field, or if unset then `X-QCS-ACCOUNT-ID` header, or if unset then requesting user's ID. * request body `accountType` field, or if unset then `X-QCS-ACCOUNT-TYPE` header, or if unset then \"user\" type.
pub async fn create_reservation(
    configuration: &configuration::Configuration,
    create_reservation_request: crate::models::CreateReservationRequest,
    x_qcs_account_id: Option<&str>,
    x_qcs_account_type: Option<models::AccountType>,
) -> Result<models::Reservation, Error<CreateReservationError>> {
    let mut backoff = configuration.backoff.clone();
    let mut refreshed_credentials = false;
    let method = reqwest::Method::POST;
    loop {
        let result = create_reservation_inner(
            configuration,
            &mut backoff,
            create_reservation_request.clone(),
            x_qcs_account_id.clone(),
            x_qcs_account_type.clone(),
        )
        .await;

        match result {
            Ok(result) => return Ok(result),
            Err(Error::ResponseError(response)) => {
                if !refreshed_credentials
                    && matches!(
                        response.status,
                        StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED
                    )
                {
                    // Attempt to refresh credentials
                    match configuration.qcs_config.refresh().await {
                        Ok(_) => {
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(::qcs_api_client_common::configuration::TokenError::Write {
                            error,
                            oauth_session: _,
                        }) => {
                            // Token refresh succeeded but persistence failed
                            // The token is already in memory and will be used for this request
                            #[cfg(feature = "tracing")]
                            tracing::warn!(
                                "Token refresh succeeded but failed to persist: {}. Continuing with in-memory token.",
                                error
                            );
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(e) => return Err(e.into()),
                    }
                } else if let Some(duration) = response.retry_delay {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::ResponseError(response));
            }
            Err(Error::Reqwest(error)) => {
                if let Some(duration) = duration_from_reqwest_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Reqwest(error));
            }
            Err(Error::Io(error)) => {
                if let Some(duration) = duration_from_io_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Io(error));
            }
            Err(error) => return Err(error),
        }
    }
}
async fn delete_reservation_inner(
    configuration: &configuration::Configuration,
    backoff: &mut ExponentialBackoff,
    reservation_id: i64,
) -> Result<models::Reservation, Error<DeleteReservationError>> {
    let local_var_configuration = configuration;
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_reservation_id = reservation_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/v1/reservations/{reservationId}",
        local_var_configuration.qcs_config.api_url(),
        reservationId = p_path_reservation_id
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::DELETE, local_var_uri_str.as_str());

    #[cfg(feature = "tracing")]
    {
        // Ignore parsing errors if the URL is invalid for some reason.
        // If it is invalid, it will turn up as an error later when actually making the request.
        let local_var_do_tracing = local_var_uri_str
            .parse::<::url::Url>()
            .ok()
            .is_none_or(|url| {
                configuration
                    .qcs_config
                    .should_trace(&::urlpattern::UrlPatternMatchInput::Url(url))
            });

        if local_var_do_tracing {
            ::tracing::debug!(
                url=%local_var_uri_str,
                method="DELETE",
                "making delete_reservation request",
            );
        }
    }

    // Use the QCS Bearer token if a client OAuthSession is present,
    // but do not require one when the security schema says it is optional.
    {
        use qcs_api_client_common::configuration::TokenError;

        #[allow(
            clippy::nonminimal_bool,
            clippy::eq_op,
            reason = "Logic must be done at runtime since it cannot be handled by the mustache template engine."
        )]
        let is_jwt_bearer_optional: bool = false || "JWTBearer" == "JWTBearerOptional";

        let token = local_var_configuration
            .qcs_config
            .get_bearer_access_token()
            .await;

        if is_jwt_bearer_optional && matches!(token, Err(TokenError::NoCredentials)) {
            // the client is configured without any OAuthSession, but this call does not require one.
            #[cfg(feature = "tracing")]
            tracing::debug!(
                "No client credentials found, but this call does not require authentication."
            );
        } else {
            local_var_req_builder = local_var_req_builder.bearer_auth(token?.secret());
        }
    }

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_raw_content_type = local_var_resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream")
        .to_string();
    let local_var_content_type = super::ContentType::from(local_var_raw_content_type.as_str());

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        let local_var_content = local_var_resp.text().await?;
        match local_var_content_type {
            ContentType::Json => serde_path_to_error::deserialize(
                &mut serde_json::Deserializer::from_str(&local_var_content),
            )
            .map_err(Error::from),
            ContentType::Text => Err(Error::InvalidContentType {
                content_type: local_var_raw_content_type,
                return_type: "models::Reservation",
            }),
            ContentType::Unsupported(unknown_type) => Err(Error::InvalidContentType {
                content_type: unknown_type,
                return_type: "models::Reservation",
            }),
        }
    } else {
        let local_var_retry_delay =
            duration_from_response(local_var_resp.status(), local_var_resp.headers(), backoff);
        let local_var_content = local_var_resp.text().await?;
        let local_var_entity: Option<DeleteReservationError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
            retry_delay: local_var_retry_delay,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// Cancel an existing reservation for the user.
pub async fn delete_reservation(
    configuration: &configuration::Configuration,
    reservation_id: i64,
) -> Result<models::Reservation, Error<DeleteReservationError>> {
    let mut backoff = configuration.backoff.clone();
    let mut refreshed_credentials = false;
    let method = reqwest::Method::DELETE;
    loop {
        let result =
            delete_reservation_inner(configuration, &mut backoff, reservation_id.clone()).await;

        match result {
            Ok(result) => return Ok(result),
            Err(Error::ResponseError(response)) => {
                if !refreshed_credentials
                    && matches!(
                        response.status,
                        StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED
                    )
                {
                    // Attempt to refresh credentials
                    match configuration.qcs_config.refresh().await {
                        Ok(_) => {
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(::qcs_api_client_common::configuration::TokenError::Write {
                            error,
                            oauth_session: _,
                        }) => {
                            // Token refresh succeeded but persistence failed
                            // The token is already in memory and will be used for this request
                            #[cfg(feature = "tracing")]
                            tracing::warn!(
                                "Token refresh succeeded but failed to persist: {}. Continuing with in-memory token.",
                                error
                            );
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(e) => return Err(e.into()),
                    }
                } else if let Some(duration) = response.retry_delay {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::ResponseError(response));
            }
            Err(Error::Reqwest(error)) => {
                if let Some(duration) = duration_from_reqwest_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Reqwest(error));
            }
            Err(Error::Io(error)) => {
                if let Some(duration) = duration_from_io_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Io(error));
            }
            Err(error) => return Err(error),
        }
    }
}
async fn find_available_reservations_inner(
    configuration: &configuration::Configuration,
    backoff: &mut ExponentialBackoff,
    quantum_processor_id: &str,
    start_time_from: String,
    duration: &str,
    page_size: Option<i64>,
    page_token: Option<&str>,
) -> Result<models::FindAvailableReservationsResponse, Error<FindAvailableReservationsError>> {
    let local_var_configuration = configuration;
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_quantum_processor_id = quantum_processor_id;
    let p_query_start_time_from = start_time_from;
    let p_query_duration = duration;
    let p_query_page_size = page_size;
    let p_query_page_token = page_token;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/v1/reservations:findAvailable",
        local_var_configuration.qcs_config.api_url()
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    #[cfg(feature = "tracing")]
    {
        // Ignore parsing errors if the URL is invalid for some reason.
        // If it is invalid, it will turn up as an error later when actually making the request.
        let local_var_do_tracing = local_var_uri_str
            .parse::<::url::Url>()
            .ok()
            .is_none_or(|url| {
                configuration
                    .qcs_config
                    .should_trace(&::urlpattern::UrlPatternMatchInput::Url(url))
            });

        if local_var_do_tracing {
            ::tracing::debug!(
                url=%local_var_uri_str,
                method="GET",
                "making find_available_reservations request",
            );
        }
    }

    if let Some(ref local_var_str) = p_query_page_size {
        local_var_req_builder =
            local_var_req_builder.query(&[("pageSize", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = p_query_page_token {
        local_var_req_builder =
            local_var_req_builder.query(&[("pageToken", &local_var_str.to_string())]);
    }
    local_var_req_builder = local_var_req_builder.query(&[(
        "quantumProcessorId",
        &p_query_quantum_processor_id.to_string(),
    )]);
    local_var_req_builder =
        local_var_req_builder.query(&[("startTimeFrom", &p_query_start_time_from.to_string())]);
    local_var_req_builder =
        local_var_req_builder.query(&[("duration", &p_query_duration.to_string())]);

    // Use the QCS Bearer token if a client OAuthSession is present,
    // but do not require one when the security schema says it is optional.
    {
        use qcs_api_client_common::configuration::TokenError;

        #[allow(
            clippy::nonminimal_bool,
            clippy::eq_op,
            reason = "Logic must be done at runtime since it cannot be handled by the mustache template engine."
        )]
        let is_jwt_bearer_optional: bool = false || "JWTBearer" == "JWTBearerOptional";

        let token = local_var_configuration
            .qcs_config
            .get_bearer_access_token()
            .await;

        if is_jwt_bearer_optional && matches!(token, Err(TokenError::NoCredentials)) {
            // the client is configured without any OAuthSession, but this call does not require one.
            #[cfg(feature = "tracing")]
            tracing::debug!(
                "No client credentials found, but this call does not require authentication."
            );
        } else {
            local_var_req_builder = local_var_req_builder.bearer_auth(token?.secret());
        }
    }

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_raw_content_type = local_var_resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream")
        .to_string();
    let local_var_content_type = super::ContentType::from(local_var_raw_content_type.as_str());

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        let local_var_content = local_var_resp.text().await?;
        match local_var_content_type {
            ContentType::Json => serde_path_to_error::deserialize(
                &mut serde_json::Deserializer::from_str(&local_var_content),
            )
            .map_err(Error::from),
            ContentType::Text => Err(Error::InvalidContentType {
                content_type: local_var_raw_content_type,
                return_type: "models::FindAvailableReservationsResponse",
            }),
            ContentType::Unsupported(unknown_type) => Err(Error::InvalidContentType {
                content_type: unknown_type,
                return_type: "models::FindAvailableReservationsResponse",
            }),
        }
    } else {
        let local_var_retry_delay =
            duration_from_response(local_var_resp.status(), local_var_resp.headers(), backoff);
        let local_var_content = local_var_resp.text().await?;
        let local_var_entity: Option<FindAvailableReservationsError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
            retry_delay: local_var_retry_delay,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// List currently available reservations on the requested Rigetti quantum computer.
pub async fn find_available_reservations(
    configuration: &configuration::Configuration,
    quantum_processor_id: &str,
    start_time_from: String,
    duration: &str,
    page_size: Option<i64>,
    page_token: Option<&str>,
) -> Result<models::FindAvailableReservationsResponse, Error<FindAvailableReservationsError>> {
    let mut backoff = configuration.backoff.clone();
    let mut refreshed_credentials = false;
    let method = reqwest::Method::GET;
    loop {
        let result = find_available_reservations_inner(
            configuration,
            &mut backoff,
            quantum_processor_id.clone(),
            start_time_from.clone(),
            duration.clone(),
            page_size.clone(),
            page_token.clone(),
        )
        .await;

        match result {
            Ok(result) => return Ok(result),
            Err(Error::ResponseError(response)) => {
                if !refreshed_credentials
                    && matches!(
                        response.status,
                        StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED
                    )
                {
                    // Attempt to refresh credentials
                    match configuration.qcs_config.refresh().await {
                        Ok(_) => {
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(::qcs_api_client_common::configuration::TokenError::Write {
                            error,
                            oauth_session: _,
                        }) => {
                            // Token refresh succeeded but persistence failed
                            // The token is already in memory and will be used for this request
                            #[cfg(feature = "tracing")]
                            tracing::warn!(
                                "Token refresh succeeded but failed to persist: {}. Continuing with in-memory token.",
                                error
                            );
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(e) => return Err(e.into()),
                    }
                } else if let Some(duration) = response.retry_delay {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::ResponseError(response));
            }
            Err(Error::Reqwest(error)) => {
                if let Some(duration) = duration_from_reqwest_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Reqwest(error));
            }
            Err(Error::Io(error)) => {
                if let Some(duration) = duration_from_io_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Io(error));
            }
            Err(error) => return Err(error),
        }
    }
}
async fn get_quantum_processor_calendar_inner(
    configuration: &configuration::Configuration,
    backoff: &mut ExponentialBackoff,
    quantum_processor_id: &str,
) -> Result<models::QuantumProcessorCalendar, Error<GetQuantumProcessorCalendarError>> {
    let local_var_configuration = configuration;
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_quantum_processor_id = quantum_processor_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/v1/calendars/{quantumProcessorId}",
        local_var_configuration.qcs_config.api_url(),
        quantumProcessorId = crate::apis::urlencode(p_path_quantum_processor_id)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    #[cfg(feature = "tracing")]
    {
        // Ignore parsing errors if the URL is invalid for some reason.
        // If it is invalid, it will turn up as an error later when actually making the request.
        let local_var_do_tracing = local_var_uri_str
            .parse::<::url::Url>()
            .ok()
            .is_none_or(|url| {
                configuration
                    .qcs_config
                    .should_trace(&::urlpattern::UrlPatternMatchInput::Url(url))
            });

        if local_var_do_tracing {
            ::tracing::debug!(
                url=%local_var_uri_str,
                method="GET",
                "making get_quantum_processor_calendar request",
            );
        }
    }

    // Use the QCS Bearer token if a client OAuthSession is present,
    // but do not require one when the security schema says it is optional.
    {
        use qcs_api_client_common::configuration::TokenError;

        #[allow(
            clippy::nonminimal_bool,
            clippy::eq_op,
            reason = "Logic must be done at runtime since it cannot be handled by the mustache template engine."
        )]
        let is_jwt_bearer_optional: bool = false || "JWTBearer" == "JWTBearerOptional";

        let token = local_var_configuration
            .qcs_config
            .get_bearer_access_token()
            .await;

        if is_jwt_bearer_optional && matches!(token, Err(TokenError::NoCredentials)) {
            // the client is configured without any OAuthSession, but this call does not require one.
            #[cfg(feature = "tracing")]
            tracing::debug!(
                "No client credentials found, but this call does not require authentication."
            );
        } else {
            local_var_req_builder = local_var_req_builder.bearer_auth(token?.secret());
        }
    }

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_raw_content_type = local_var_resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream")
        .to_string();
    let local_var_content_type = super::ContentType::from(local_var_raw_content_type.as_str());

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        let local_var_content = local_var_resp.text().await?;
        match local_var_content_type {
            ContentType::Json => serde_path_to_error::deserialize(
                &mut serde_json::Deserializer::from_str(&local_var_content),
            )
            .map_err(Error::from),
            ContentType::Text => Err(Error::InvalidContentType {
                content_type: local_var_raw_content_type,
                return_type: "models::QuantumProcessorCalendar",
            }),
            ContentType::Unsupported(unknown_type) => Err(Error::InvalidContentType {
                content_type: unknown_type,
                return_type: "models::QuantumProcessorCalendar",
            }),
        }
    } else {
        let local_var_retry_delay =
            duration_from_response(local_var_resp.status(), local_var_resp.headers(), backoff);
        let local_var_content = local_var_resp.text().await?;
        let local_var_entity: Option<GetQuantumProcessorCalendarError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
            retry_delay: local_var_retry_delay,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// Get calendar details for the requested quantum processor.
pub async fn get_quantum_processor_calendar(
    configuration: &configuration::Configuration,
    quantum_processor_id: &str,
) -> Result<models::QuantumProcessorCalendar, Error<GetQuantumProcessorCalendarError>> {
    let mut backoff = configuration.backoff.clone();
    let mut refreshed_credentials = false;
    let method = reqwest::Method::GET;
    loop {
        let result = get_quantum_processor_calendar_inner(
            configuration,
            &mut backoff,
            quantum_processor_id.clone(),
        )
        .await;

        match result {
            Ok(result) => return Ok(result),
            Err(Error::ResponseError(response)) => {
                if !refreshed_credentials
                    && matches!(
                        response.status,
                        StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED
                    )
                {
                    // Attempt to refresh credentials
                    match configuration.qcs_config.refresh().await {
                        Ok(_) => {
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(::qcs_api_client_common::configuration::TokenError::Write {
                            error,
                            oauth_session: _,
                        }) => {
                            // Token refresh succeeded but persistence failed
                            // The token is already in memory and will be used for this request
                            #[cfg(feature = "tracing")]
                            tracing::warn!(
                                "Token refresh succeeded but failed to persist: {}. Continuing with in-memory token.",
                                error
                            );
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(e) => return Err(e.into()),
                    }
                } else if let Some(duration) = response.retry_delay {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::ResponseError(response));
            }
            Err(Error::Reqwest(error)) => {
                if let Some(duration) = duration_from_reqwest_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Reqwest(error));
            }
            Err(Error::Io(error)) => {
                if let Some(duration) = duration_from_io_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Io(error));
            }
            Err(error) => return Err(error),
        }
    }
}
async fn get_reservation_inner(
    configuration: &configuration::Configuration,
    backoff: &mut ExponentialBackoff,
    reservation_id: i64,
) -> Result<models::Reservation, Error<GetReservationError>> {
    let local_var_configuration = configuration;
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_reservation_id = reservation_id;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/v1/reservations/{reservationId}",
        local_var_configuration.qcs_config.api_url(),
        reservationId = p_path_reservation_id
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    #[cfg(feature = "tracing")]
    {
        // Ignore parsing errors if the URL is invalid for some reason.
        // If it is invalid, it will turn up as an error later when actually making the request.
        let local_var_do_tracing = local_var_uri_str
            .parse::<::url::Url>()
            .ok()
            .is_none_or(|url| {
                configuration
                    .qcs_config
                    .should_trace(&::urlpattern::UrlPatternMatchInput::Url(url))
            });

        if local_var_do_tracing {
            ::tracing::debug!(
                url=%local_var_uri_str,
                method="GET",
                "making get_reservation request",
            );
        }
    }

    // Use the QCS Bearer token if a client OAuthSession is present,
    // but do not require one when the security schema says it is optional.
    {
        use qcs_api_client_common::configuration::TokenError;

        #[allow(
            clippy::nonminimal_bool,
            clippy::eq_op,
            reason = "Logic must be done at runtime since it cannot be handled by the mustache template engine."
        )]
        let is_jwt_bearer_optional: bool = false || "JWTBearer" == "JWTBearerOptional";

        let token = local_var_configuration
            .qcs_config
            .get_bearer_access_token()
            .await;

        if is_jwt_bearer_optional && matches!(token, Err(TokenError::NoCredentials)) {
            // the client is configured without any OAuthSession, but this call does not require one.
            #[cfg(feature = "tracing")]
            tracing::debug!(
                "No client credentials found, but this call does not require authentication."
            );
        } else {
            local_var_req_builder = local_var_req_builder.bearer_auth(token?.secret());
        }
    }

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_raw_content_type = local_var_resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream")
        .to_string();
    let local_var_content_type = super::ContentType::from(local_var_raw_content_type.as_str());

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        let local_var_content = local_var_resp.text().await?;
        match local_var_content_type {
            ContentType::Json => serde_path_to_error::deserialize(
                &mut serde_json::Deserializer::from_str(&local_var_content),
            )
            .map_err(Error::from),
            ContentType::Text => Err(Error::InvalidContentType {
                content_type: local_var_raw_content_type,
                return_type: "models::Reservation",
            }),
            ContentType::Unsupported(unknown_type) => Err(Error::InvalidContentType {
                content_type: unknown_type,
                return_type: "models::Reservation",
            }),
        }
    } else {
        let local_var_retry_delay =
            duration_from_response(local_var_resp.status(), local_var_resp.headers(), backoff);
        let local_var_content = local_var_resp.text().await?;
        let local_var_entity: Option<GetReservationError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
            retry_delay: local_var_retry_delay,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// Find an existing reservation by ID.
pub async fn get_reservation(
    configuration: &configuration::Configuration,
    reservation_id: i64,
) -> Result<models::Reservation, Error<GetReservationError>> {
    let mut backoff = configuration.backoff.clone();
    let mut refreshed_credentials = false;
    let method = reqwest::Method::GET;
    loop {
        let result =
            get_reservation_inner(configuration, &mut backoff, reservation_id.clone()).await;

        match result {
            Ok(result) => return Ok(result),
            Err(Error::ResponseError(response)) => {
                if !refreshed_credentials
                    && matches!(
                        response.status,
                        StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED
                    )
                {
                    // Attempt to refresh credentials
                    match configuration.qcs_config.refresh().await {
                        Ok(_) => {
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(::qcs_api_client_common::configuration::TokenError::Write {
                            error,
                            oauth_session: _,
                        }) => {
                            // Token refresh succeeded but persistence failed
                            // The token is already in memory and will be used for this request
                            #[cfg(feature = "tracing")]
                            tracing::warn!(
                                "Token refresh succeeded but failed to persist: {}. Continuing with in-memory token.",
                                error
                            );
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(e) => return Err(e.into()),
                    }
                } else if let Some(duration) = response.retry_delay {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::ResponseError(response));
            }
            Err(Error::Reqwest(error)) => {
                if let Some(duration) = duration_from_reqwest_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Reqwest(error));
            }
            Err(Error::Io(error)) => {
                if let Some(duration) = duration_from_io_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Io(error));
            }
            Err(error) => return Err(error),
        }
    }
}
async fn list_group_reservations_inner(
    configuration: &configuration::Configuration,
    backoff: &mut ExponentialBackoff,
    group_name: &str,
    filter: Option<&str>,
    order: Option<&str>,
    page_size: Option<i64>,
    page_token: Option<&str>,
    show_deleted: Option<&str>,
) -> Result<models::ListReservationsResponse, Error<ListGroupReservationsError>> {
    let local_var_configuration = configuration;
    // add a prefix to parameters to efficiently prevent name collisions
    let p_path_group_name = group_name;
    let p_query_filter = filter;
    let p_query_order = order;
    let p_query_page_size = page_size;
    let p_query_page_token = page_token;
    let p_query_show_deleted = show_deleted;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/v1/groups/{groupName}/reservations",
        local_var_configuration.qcs_config.api_url(),
        groupName = crate::apis::urlencode(p_path_group_name)
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    #[cfg(feature = "tracing")]
    {
        // Ignore parsing errors if the URL is invalid for some reason.
        // If it is invalid, it will turn up as an error later when actually making the request.
        let local_var_do_tracing = local_var_uri_str
            .parse::<::url::Url>()
            .ok()
            .is_none_or(|url| {
                configuration
                    .qcs_config
                    .should_trace(&::urlpattern::UrlPatternMatchInput::Url(url))
            });

        if local_var_do_tracing {
            ::tracing::debug!(
                url=%local_var_uri_str,
                method="GET",
                "making list_group_reservations request",
            );
        }
    }

    if let Some(ref local_var_str) = p_query_filter {
        local_var_req_builder =
            local_var_req_builder.query(&[("filter", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = p_query_order {
        local_var_req_builder =
            local_var_req_builder.query(&[("order", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = p_query_page_size {
        local_var_req_builder =
            local_var_req_builder.query(&[("pageSize", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = p_query_page_token {
        local_var_req_builder =
            local_var_req_builder.query(&[("pageToken", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = p_query_show_deleted {
        local_var_req_builder =
            local_var_req_builder.query(&[("showDeleted", &local_var_str.to_string())]);
    }

    // Use the QCS Bearer token if a client OAuthSession is present,
    // but do not require one when the security schema says it is optional.
    {
        use qcs_api_client_common::configuration::TokenError;

        #[allow(
            clippy::nonminimal_bool,
            clippy::eq_op,
            reason = "Logic must be done at runtime since it cannot be handled by the mustache template engine."
        )]
        let is_jwt_bearer_optional: bool = false || "JWTBearer" == "JWTBearerOptional";

        let token = local_var_configuration
            .qcs_config
            .get_bearer_access_token()
            .await;

        if is_jwt_bearer_optional && matches!(token, Err(TokenError::NoCredentials)) {
            // the client is configured without any OAuthSession, but this call does not require one.
            #[cfg(feature = "tracing")]
            tracing::debug!(
                "No client credentials found, but this call does not require authentication."
            );
        } else {
            local_var_req_builder = local_var_req_builder.bearer_auth(token?.secret());
        }
    }

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_raw_content_type = local_var_resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream")
        .to_string();
    let local_var_content_type = super::ContentType::from(local_var_raw_content_type.as_str());

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        let local_var_content = local_var_resp.text().await?;
        match local_var_content_type {
            ContentType::Json => serde_path_to_error::deserialize(
                &mut serde_json::Deserializer::from_str(&local_var_content),
            )
            .map_err(Error::from),
            ContentType::Text => Err(Error::InvalidContentType {
                content_type: local_var_raw_content_type,
                return_type: "models::ListReservationsResponse",
            }),
            ContentType::Unsupported(unknown_type) => Err(Error::InvalidContentType {
                content_type: unknown_type,
                return_type: "models::ListReservationsResponse",
            }),
        }
    } else {
        let local_var_retry_delay =
            duration_from_response(local_var_resp.status(), local_var_resp.headers(), backoff);
        let local_var_content = local_var_resp.text().await?;
        let local_var_entity: Option<ListGroupReservationsError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
            retry_delay: local_var_retry_delay,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// List existing reservations for the requested group.  Available filter fields include:  * `startTime` - timestamp * `endTime` - timestamp * `createdTime` - timestamp * `price` - integer * `quantumProcessorId` - string  Available order fields include:  * `startTime` - timestamp * `endTime` - timestamp * `createdTime` - timestamp * `price` - integer
pub async fn list_group_reservations(
    configuration: &configuration::Configuration,
    group_name: &str,
    filter: Option<&str>,
    order: Option<&str>,
    page_size: Option<i64>,
    page_token: Option<&str>,
    show_deleted: Option<&str>,
) -> Result<models::ListReservationsResponse, Error<ListGroupReservationsError>> {
    let mut backoff = configuration.backoff.clone();
    let mut refreshed_credentials = false;
    let method = reqwest::Method::GET;
    loop {
        let result = list_group_reservations_inner(
            configuration,
            &mut backoff,
            group_name.clone(),
            filter.clone(),
            order.clone(),
            page_size.clone(),
            page_token.clone(),
            show_deleted.clone(),
        )
        .await;

        match result {
            Ok(result) => return Ok(result),
            Err(Error::ResponseError(response)) => {
                if !refreshed_credentials
                    && matches!(
                        response.status,
                        StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED
                    )
                {
                    // Attempt to refresh credentials
                    match configuration.qcs_config.refresh().await {
                        Ok(_) => {
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(::qcs_api_client_common::configuration::TokenError::Write {
                            error,
                            oauth_session: _,
                        }) => {
                            // Token refresh succeeded but persistence failed
                            // The token is already in memory and will be used for this request
                            #[cfg(feature = "tracing")]
                            tracing::warn!(
                                "Token refresh succeeded but failed to persist: {}. Continuing with in-memory token.",
                                error
                            );
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(e) => return Err(e.into()),
                    }
                } else if let Some(duration) = response.retry_delay {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::ResponseError(response));
            }
            Err(Error::Reqwest(error)) => {
                if let Some(duration) = duration_from_reqwest_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Reqwest(error));
            }
            Err(Error::Io(error)) => {
                if let Some(duration) = duration_from_io_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Io(error));
            }
            Err(error) => return Err(error),
        }
    }
}
async fn list_reservations_inner(
    configuration: &configuration::Configuration,
    backoff: &mut ExponentialBackoff,
    filter: Option<&str>,
    order: Option<&str>,
    page_size: Option<i64>,
    page_token: Option<&str>,
    show_deleted: Option<&str>,
    x_qcs_account_id: Option<&str>,
    x_qcs_account_type: Option<models::AccountType>,
) -> Result<models::ListReservationsResponse, Error<ListReservationsError>> {
    let local_var_configuration = configuration;
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_order = order;
    let p_query_page_size = page_size;
    let p_query_page_token = page_token;
    let p_query_show_deleted = show_deleted;
    let p_header_x_qcs_account_id = x_qcs_account_id;
    let p_header_x_qcs_account_type = x_qcs_account_type;

    let local_var_client = &local_var_configuration.client;

    let local_var_uri_str = format!(
        "{}/v1/reservations",
        local_var_configuration.qcs_config.api_url()
    );
    let mut local_var_req_builder =
        local_var_client.request(reqwest::Method::GET, local_var_uri_str.as_str());

    #[cfg(feature = "tracing")]
    {
        // Ignore parsing errors if the URL is invalid for some reason.
        // If it is invalid, it will turn up as an error later when actually making the request.
        let local_var_do_tracing = local_var_uri_str
            .parse::<::url::Url>()
            .ok()
            .is_none_or(|url| {
                configuration
                    .qcs_config
                    .should_trace(&::urlpattern::UrlPatternMatchInput::Url(url))
            });

        if local_var_do_tracing {
            ::tracing::debug!(
                url=%local_var_uri_str,
                method="GET",
                "making list_reservations request",
            );
        }
    }

    if let Some(ref local_var_str) = p_query_filter {
        local_var_req_builder =
            local_var_req_builder.query(&[("filter", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = p_query_order {
        local_var_req_builder =
            local_var_req_builder.query(&[("order", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = p_query_page_size {
        local_var_req_builder =
            local_var_req_builder.query(&[("pageSize", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = p_query_page_token {
        local_var_req_builder =
            local_var_req_builder.query(&[("pageToken", &local_var_str.to_string())]);
    }
    if let Some(ref local_var_str) = p_query_show_deleted {
        local_var_req_builder =
            local_var_req_builder.query(&[("showDeleted", &local_var_str.to_string())]);
    }
    if let Some(local_var_param_value) = p_header_x_qcs_account_id {
        local_var_req_builder =
            local_var_req_builder.header("x-qcs-account-id", local_var_param_value.to_string());
    }
    if let Some(local_var_param_value) = p_header_x_qcs_account_type {
        local_var_req_builder =
            local_var_req_builder.header("x-qcs-account-type", local_var_param_value.to_string());
    }

    // Use the QCS Bearer token if a client OAuthSession is present,
    // but do not require one when the security schema says it is optional.
    {
        use qcs_api_client_common::configuration::TokenError;

        #[allow(
            clippy::nonminimal_bool,
            clippy::eq_op,
            reason = "Logic must be done at runtime since it cannot be handled by the mustache template engine."
        )]
        let is_jwt_bearer_optional: bool = false || "JWTBearer" == "JWTBearerOptional";

        let token = local_var_configuration
            .qcs_config
            .get_bearer_access_token()
            .await;

        if is_jwt_bearer_optional && matches!(token, Err(TokenError::NoCredentials)) {
            // the client is configured without any OAuthSession, but this call does not require one.
            #[cfg(feature = "tracing")]
            tracing::debug!(
                "No client credentials found, but this call does not require authentication."
            );
        } else {
            local_var_req_builder = local_var_req_builder.bearer_auth(token?.secret());
        }
    }

    let local_var_req = local_var_req_builder.build()?;
    let local_var_resp = local_var_client.execute(local_var_req).await?;

    let local_var_status = local_var_resp.status();
    let local_var_raw_content_type = local_var_resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream")
        .to_string();
    let local_var_content_type = super::ContentType::from(local_var_raw_content_type.as_str());

    if !local_var_status.is_client_error() && !local_var_status.is_server_error() {
        let local_var_content = local_var_resp.text().await?;
        match local_var_content_type {
            ContentType::Json => serde_path_to_error::deserialize(
                &mut serde_json::Deserializer::from_str(&local_var_content),
            )
            .map_err(Error::from),
            ContentType::Text => Err(Error::InvalidContentType {
                content_type: local_var_raw_content_type,
                return_type: "models::ListReservationsResponse",
            }),
            ContentType::Unsupported(unknown_type) => Err(Error::InvalidContentType {
                content_type: unknown_type,
                return_type: "models::ListReservationsResponse",
            }),
        }
    } else {
        let local_var_retry_delay =
            duration_from_response(local_var_resp.status(), local_var_resp.headers(), backoff);
        let local_var_content = local_var_resp.text().await?;
        let local_var_entity: Option<ListReservationsError> =
            serde_json::from_str(&local_var_content).ok();
        let local_var_error = ResponseContent {
            status: local_var_status,
            content: local_var_content,
            entity: local_var_entity,
            retry_delay: local_var_retry_delay,
        };
        Err(Error::ResponseError(local_var_error))
    }
}

/// List existing reservations for the authenticated user, or a target user when specifying `X-QCS-ACCOUNT-ID` and `X-QCS-ACCOUNT-TYPE` headers.  Available filter fields include:  * `startTime` - timestamp * `endTime` - timestamp * `createdTime` - timestamp * `price` - integer * `cancelled` - boolean (deprecated, use `showDeleted` parameter) * `quantumProcessorId` - string  Available order fields include:  * `startTime` - timestamp * `endTime` - timestamp * `createdTime` - timestamp * `price` - integer
pub async fn list_reservations(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    order: Option<&str>,
    page_size: Option<i64>,
    page_token: Option<&str>,
    show_deleted: Option<&str>,
    x_qcs_account_id: Option<&str>,
    x_qcs_account_type: Option<models::AccountType>,
) -> Result<models::ListReservationsResponse, Error<ListReservationsError>> {
    let mut backoff = configuration.backoff.clone();
    let mut refreshed_credentials = false;
    let method = reqwest::Method::GET;
    loop {
        let result = list_reservations_inner(
            configuration,
            &mut backoff,
            filter.clone(),
            order.clone(),
            page_size.clone(),
            page_token.clone(),
            show_deleted.clone(),
            x_qcs_account_id.clone(),
            x_qcs_account_type.clone(),
        )
        .await;

        match result {
            Ok(result) => return Ok(result),
            Err(Error::ResponseError(response)) => {
                if !refreshed_credentials
                    && matches!(
                        response.status,
                        StatusCode::FORBIDDEN | StatusCode::UNAUTHORIZED
                    )
                {
                    // Attempt to refresh credentials
                    match configuration.qcs_config.refresh().await {
                        Ok(_) => {
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(::qcs_api_client_common::configuration::TokenError::Write {
                            error,
                            oauth_session: _,
                        }) => {
                            // Token refresh succeeded but persistence failed
                            // The token is already in memory and will be used for this request
                            #[cfg(feature = "tracing")]
                            tracing::warn!(
                                "Token refresh succeeded but failed to persist: {}. Continuing with in-memory token.",
                                error
                            );
                            refreshed_credentials = true;
                            continue;
                        }
                        Err(e) => return Err(e.into()),
                    }
                } else if let Some(duration) = response.retry_delay {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::ResponseError(response));
            }
            Err(Error::Reqwest(error)) => {
                if let Some(duration) = duration_from_reqwest_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Reqwest(error));
            }
            Err(Error::Io(error)) => {
                if let Some(duration) = duration_from_io_error(&method, &error, &mut backoff) {
                    tokio::time::sleep(duration).await;
                    continue;
                }

                return Err(Error::Io(error));
            }
            Err(error) => return Err(error),
        }
    }
}