google-cloud-sql-v1 2.5.0

// Copyright 2025 Google LLC
//
// 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
//
//     https://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.
//
// Code generated by sidekick. DO NOT EDIT.

/// A dyn-compatible, crate-private version of [super::SqlBackupRunsService].
#[async_trait::async_trait]
pub trait SqlBackupRunsService: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::SqlBackupRunsDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::SqlBackupRunsGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::BackupRun>>;

    async fn insert(
        &self,
        req: crate::model::SqlBackupRunsInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::SqlBackupRunsListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::BackupRunsListResponse>>;
}

/// All implementations of [super::SqlBackupRunsService] also implement [SqlBackupRunsService].
#[async_trait::async_trait]
impl<T: super::SqlBackupRunsService> SqlBackupRunsService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::SqlBackupRunsDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::SqlBackupRunsGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::BackupRun>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::SqlBackupRunsInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::SqlBackupRunsListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::BackupRunsListResponse>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::SqlBackupsService].
#[async_trait::async_trait]
pub trait SqlBackupsService: std::fmt::Debug + Send + Sync {
    async fn create_backup(
        &self,
        req: crate::model::CreateBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn get_backup(
        &self,
        req: crate::model::GetBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Backup>>;

    async fn list_backups(
        &self,
        req: crate::model::ListBackupsRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ListBackupsResponse>>;

    async fn update_backup(
        &self,
        req: crate::model::UpdateBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn delete_backup(
        &self,
        req: crate::model::DeleteBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;
}

/// All implementations of [super::SqlBackupsService] also implement [SqlBackupsService].
#[async_trait::async_trait]
impl<T: super::SqlBackupsService> SqlBackupsService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn create_backup(
        &self,
        req: crate::model::CreateBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::create_backup(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_backup(
        &self,
        req: crate::model::GetBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Backup>> {
        T::get_backup(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_backups(
        &self,
        req: crate::model::ListBackupsRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ListBackupsResponse>> {
        T::list_backups(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update_backup(
        &self,
        req: crate::model::UpdateBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::update_backup(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete_backup(
        &self,
        req: crate::model::DeleteBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::delete_backup(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::SqlConnectService].
#[async_trait::async_trait]
pub trait SqlConnectService: std::fmt::Debug + Send + Sync {
    async fn get_connect_settings(
        &self,
        req: crate::model::GetConnectSettingsRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ConnectSettings>>;

    async fn generate_ephemeral_cert(
        &self,
        req: crate::model::GenerateEphemeralCertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::GenerateEphemeralCertResponse>>;
}

/// All implementations of [super::SqlConnectService] also implement [SqlConnectService].
#[async_trait::async_trait]
impl<T: super::SqlConnectService> SqlConnectService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get_connect_settings(
        &self,
        req: crate::model::GetConnectSettingsRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::ConnectSettings>> {
        T::get_connect_settings(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn generate_ephemeral_cert(
        &self,
        req: crate::model::GenerateEphemeralCertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::GenerateEphemeralCertResponse>> {
        T::generate_ephemeral_cert(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::SqlDatabasesService].
#[async_trait::async_trait]
pub trait SqlDatabasesService: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::SqlDatabasesDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::SqlDatabasesGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Database>>;

    async fn insert(
        &self,
        req: crate::model::SqlDatabasesInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::SqlDatabasesListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::DatabasesListResponse>>;

    async fn patch(
        &self,
        req: crate::model::SqlDatabasesUpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::SqlDatabasesUpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;
}

/// All implementations of [super::SqlDatabasesService] also implement [SqlDatabasesService].
#[async_trait::async_trait]
impl<T: super::SqlDatabasesService> SqlDatabasesService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::SqlDatabasesDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::SqlDatabasesGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Database>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::SqlDatabasesInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::SqlDatabasesListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::DatabasesListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::SqlDatabasesUpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::SqlDatabasesUpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::SqlFlagsService].
#[async_trait::async_trait]
pub trait SqlFlagsService: std::fmt::Debug + Send + Sync {
    async fn list(
        &self,
        req: crate::model::SqlFlagsListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::FlagsListResponse>>;
}

/// All implementations of [super::SqlFlagsService] also implement [SqlFlagsService].
#[async_trait::async_trait]
impl<T: super::SqlFlagsService> SqlFlagsService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::SqlFlagsListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::FlagsListResponse>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::SqlInstancesService].
#[async_trait::async_trait]
pub trait SqlInstancesService: std::fmt::Debug + Send + Sync {
    async fn add_server_ca(
        &self,
        req: crate::model::SqlInstancesAddServerCaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn add_server_certificate(
        &self,
        req: crate::model::SqlInstancesAddServerCertificateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn add_entra_id_certificate(
        &self,
        req: crate::model::SqlInstancesAddEntraIdCertificateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn clone(
        &self,
        req: crate::model::SqlInstancesCloneRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn delete(
        &self,
        req: crate::model::SqlInstancesDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn demote_master(
        &self,
        req: crate::model::SqlInstancesDemoteMasterRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn demote(
        &self,
        req: crate::model::SqlInstancesDemoteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn export(
        &self,
        req: crate::model::SqlInstancesExportRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn failover(
        &self,
        req: crate::model::SqlInstancesFailoverRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn reencrypt(
        &self,
        req: crate::model::SqlInstancesReencryptRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::SqlInstancesGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::DatabaseInstance>>;

    async fn import(
        &self,
        req: crate::model::SqlInstancesImportRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn insert(
        &self,
        req: crate::model::SqlInstancesInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::SqlInstancesListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::InstancesListResponse>>;

    async fn list_server_cas(
        &self,
        req: crate::model::SqlInstancesListServerCasRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::InstancesListServerCasResponse>>;

    async fn list_server_certificates(
        &self,
        req: crate::model::SqlInstancesListServerCertificatesRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::InstancesListServerCertificatesResponse>>;

    async fn list_entra_id_certificates(
        &self,
        req: crate::model::SqlInstancesListEntraIdCertificatesRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::InstancesListEntraIdCertificatesResponse>>;

    async fn patch(
        &self,
        req: crate::model::SqlInstancesPatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn promote_replica(
        &self,
        req: crate::model::SqlInstancesPromoteReplicaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn switchover(
        &self,
        req: crate::model::SqlInstancesSwitchoverRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn reset_ssl_config(
        &self,
        req: crate::model::SqlInstancesResetSslConfigRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn restart(
        &self,
        req: crate::model::SqlInstancesRestartRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn restore_backup(
        &self,
        req: crate::model::SqlInstancesRestoreBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn rotate_server_ca(
        &self,
        req: crate::model::SqlInstancesRotateServerCaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn rotate_server_certificate(
        &self,
        req: crate::model::SqlInstancesRotateServerCertificateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn rotate_entra_id_certificate(
        &self,
        req: crate::model::SqlInstancesRotateEntraIdCertificateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn start_replica(
        &self,
        req: crate::model::SqlInstancesStartReplicaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn stop_replica(
        &self,
        req: crate::model::SqlInstancesStopReplicaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn truncate_log(
        &self,
        req: crate::model::SqlInstancesTruncateLogRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn update(
        &self,
        req: crate::model::SqlInstancesUpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn create_ephemeral(
        &self,
        req: crate::model::SqlInstancesCreateEphemeralCertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SslCert>>;

    async fn reschedule_maintenance(
        &self,
        req: crate::model::SqlInstancesRescheduleMaintenanceRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn verify_external_sync_settings(
        &self,
        req: crate::model::SqlInstancesVerifyExternalSyncSettingsRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesVerifyExternalSyncSettingsResponse>>;

    async fn start_external_sync(
        &self,
        req: crate::model::SqlInstancesStartExternalSyncRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn perform_disk_shrink(
        &self,
        req: crate::model::SqlInstancesPerformDiskShrinkRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn get_disk_shrink_config(
        &self,
        req: crate::model::SqlInstancesGetDiskShrinkConfigRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesGetDiskShrinkConfigResponse>>;

    async fn reset_replica_size(
        &self,
        req: crate::model::SqlInstancesResetReplicaSizeRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn get_latest_recovery_time(
        &self,
        req: crate::model::SqlInstancesGetLatestRecoveryTimeRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesGetLatestRecoveryTimeResponse>>;

    async fn execute_sql(
        &self,
        req: crate::model::SqlInstancesExecuteSqlRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesExecuteSqlResponse>>;

    async fn acquire_ssrs_lease(
        &self,
        req: crate::model::SqlInstancesAcquireSsrsLeaseRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesAcquireSsrsLeaseResponse>>;

    async fn release_ssrs_lease(
        &self,
        req: crate::model::SqlInstancesReleaseSsrsLeaseRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesReleaseSsrsLeaseResponse>>;

    async fn pre_check_major_version_upgrade(
        &self,
        req: crate::model::SqlInstancesPreCheckMajorVersionUpgradeRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn point_in_time_restore(
        &self,
        req: crate::model::SqlInstancesPointInTimeRestoreRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;
}

/// All implementations of [super::SqlInstancesService] also implement [SqlInstancesService].
#[async_trait::async_trait]
impl<T: super::SqlInstancesService> SqlInstancesService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn add_server_ca(
        &self,
        req: crate::model::SqlInstancesAddServerCaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::add_server_ca(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_server_certificate(
        &self,
        req: crate::model::SqlInstancesAddServerCertificateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::add_server_certificate(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn add_entra_id_certificate(
        &self,
        req: crate::model::SqlInstancesAddEntraIdCertificateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::add_entra_id_certificate(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn clone(
        &self,
        req: crate::model::SqlInstancesCloneRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::clone(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::SqlInstancesDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn demote_master(
        &self,
        req: crate::model::SqlInstancesDemoteMasterRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::demote_master(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn demote(
        &self,
        req: crate::model::SqlInstancesDemoteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::demote(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn export(
        &self,
        req: crate::model::SqlInstancesExportRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::export(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn failover(
        &self,
        req: crate::model::SqlInstancesFailoverRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::failover(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn reencrypt(
        &self,
        req: crate::model::SqlInstancesReencryptRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::reencrypt(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::SqlInstancesGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::DatabaseInstance>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn import(
        &self,
        req: crate::model::SqlInstancesImportRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::import(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::SqlInstancesInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::SqlInstancesListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::InstancesListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_server_cas(
        &self,
        req: crate::model::SqlInstancesListServerCasRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::InstancesListServerCasResponse>> {
        T::list_server_cas(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_server_certificates(
        &self,
        req: crate::model::SqlInstancesListServerCertificatesRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::InstancesListServerCertificatesResponse>> {
        T::list_server_certificates(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list_entra_id_certificates(
        &self,
        req: crate::model::SqlInstancesListEntraIdCertificatesRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::InstancesListEntraIdCertificatesResponse>>
    {
        T::list_entra_id_certificates(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn patch(
        &self,
        req: crate::model::SqlInstancesPatchRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::patch(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn promote_replica(
        &self,
        req: crate::model::SqlInstancesPromoteReplicaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::promote_replica(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn switchover(
        &self,
        req: crate::model::SqlInstancesSwitchoverRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::switchover(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn reset_ssl_config(
        &self,
        req: crate::model::SqlInstancesResetSslConfigRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::reset_ssl_config(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn restart(
        &self,
        req: crate::model::SqlInstancesRestartRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::restart(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn restore_backup(
        &self,
        req: crate::model::SqlInstancesRestoreBackupRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::restore_backup(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn rotate_server_ca(
        &self,
        req: crate::model::SqlInstancesRotateServerCaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::rotate_server_ca(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn rotate_server_certificate(
        &self,
        req: crate::model::SqlInstancesRotateServerCertificateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::rotate_server_certificate(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn rotate_entra_id_certificate(
        &self,
        req: crate::model::SqlInstancesRotateEntraIdCertificateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::rotate_entra_id_certificate(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn start_replica(
        &self,
        req: crate::model::SqlInstancesStartReplicaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::start_replica(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn stop_replica(
        &self,
        req: crate::model::SqlInstancesStopReplicaRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::stop_replica(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn truncate_log(
        &self,
        req: crate::model::SqlInstancesTruncateLogRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::truncate_log(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::SqlInstancesUpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn create_ephemeral(
        &self,
        req: crate::model::SqlInstancesCreateEphemeralCertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SslCert>> {
        T::create_ephemeral(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn reschedule_maintenance(
        &self,
        req: crate::model::SqlInstancesRescheduleMaintenanceRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::reschedule_maintenance(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn verify_external_sync_settings(
        &self,
        req: crate::model::SqlInstancesVerifyExternalSyncSettingsRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesVerifyExternalSyncSettingsResponse>>
    {
        T::verify_external_sync_settings(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn start_external_sync(
        &self,
        req: crate::model::SqlInstancesStartExternalSyncRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::start_external_sync(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn perform_disk_shrink(
        &self,
        req: crate::model::SqlInstancesPerformDiskShrinkRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::perform_disk_shrink(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_disk_shrink_config(
        &self,
        req: crate::model::SqlInstancesGetDiskShrinkConfigRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesGetDiskShrinkConfigResponse>> {
        T::get_disk_shrink_config(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn reset_replica_size(
        &self,
        req: crate::model::SqlInstancesResetReplicaSizeRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::reset_replica_size(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get_latest_recovery_time(
        &self,
        req: crate::model::SqlInstancesGetLatestRecoveryTimeRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesGetLatestRecoveryTimeResponse>>
    {
        T::get_latest_recovery_time(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn execute_sql(
        &self,
        req: crate::model::SqlInstancesExecuteSqlRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesExecuteSqlResponse>> {
        T::execute_sql(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn acquire_ssrs_lease(
        &self,
        req: crate::model::SqlInstancesAcquireSsrsLeaseRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesAcquireSsrsLeaseResponse>> {
        T::acquire_ssrs_lease(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn release_ssrs_lease(
        &self,
        req: crate::model::SqlInstancesReleaseSsrsLeaseRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SqlInstancesReleaseSsrsLeaseResponse>> {
        T::release_ssrs_lease(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn pre_check_major_version_upgrade(
        &self,
        req: crate::model::SqlInstancesPreCheckMajorVersionUpgradeRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::pre_check_major_version_upgrade(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn point_in_time_restore(
        &self,
        req: crate::model::SqlInstancesPointInTimeRestoreRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::point_in_time_restore(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::SqlOperationsService].
#[async_trait::async_trait]
pub trait SqlOperationsService: std::fmt::Debug + Send + Sync {
    async fn get(
        &self,
        req: crate::model::SqlOperationsGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::SqlOperationsListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::OperationsListResponse>>;

    async fn cancel(
        &self,
        req: crate::model::SqlOperationsCancelRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>>;
}

/// All implementations of [super::SqlOperationsService] also implement [SqlOperationsService].
#[async_trait::async_trait]
impl<T: super::SqlOperationsService> SqlOperationsService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::SqlOperationsGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::SqlOperationsListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::OperationsListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn cancel(
        &self,
        req: crate::model::SqlOperationsCancelRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<()>> {
        T::cancel(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::SqlSslCertsService].
#[async_trait::async_trait]
pub trait SqlSslCertsService: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::SqlSslCertsDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::SqlSslCertsGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SslCert>>;

    async fn insert(
        &self,
        req: crate::model::SqlSslCertsInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SslCertsInsertResponse>>;

    async fn list(
        &self,
        req: crate::model::SqlSslCertsListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SslCertsListResponse>>;
}

/// All implementations of [super::SqlSslCertsService] also implement [SqlSslCertsService].
#[async_trait::async_trait]
impl<T: super::SqlSslCertsService> SqlSslCertsService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::SqlSslCertsDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::SqlSslCertsGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SslCert>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::SqlSslCertsInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SslCertsInsertResponse>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::SqlSslCertsListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::SslCertsListResponse>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::SqlTiersService].
#[async_trait::async_trait]
pub trait SqlTiersService: std::fmt::Debug + Send + Sync {
    async fn list(
        &self,
        req: crate::model::SqlTiersListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::TiersListResponse>>;
}

/// All implementations of [super::SqlTiersService] also implement [SqlTiersService].
#[async_trait::async_trait]
impl<T: super::SqlTiersService> SqlTiersService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::SqlTiersListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::TiersListResponse>> {
        T::list(self, req, options).await
    }
}

/// A dyn-compatible, crate-private version of [super::SqlUsersService].
#[async_trait::async_trait]
pub trait SqlUsersService: std::fmt::Debug + Send + Sync {
    async fn delete(
        &self,
        req: crate::model::SqlUsersDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn get(
        &self,
        req: crate::model::SqlUsersGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::User>>;

    async fn insert(
        &self,
        req: crate::model::SqlUsersInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;

    async fn list(
        &self,
        req: crate::model::SqlUsersListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::UsersListResponse>>;

    async fn update(
        &self,
        req: crate::model::SqlUsersUpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>>;
}

/// All implementations of [super::SqlUsersService] also implement [SqlUsersService].
#[async_trait::async_trait]
impl<T: super::SqlUsersService> SqlUsersService for T {
    /// Forwards the call to the implementation provided by `T`.
    async fn delete(
        &self,
        req: crate::model::SqlUsersDeleteRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::delete(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn get(
        &self,
        req: crate::model::SqlUsersGetRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::User>> {
        T::get(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn insert(
        &self,
        req: crate::model::SqlUsersInsertRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::insert(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn list(
        &self,
        req: crate::model::SqlUsersListRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::UsersListResponse>> {
        T::list(self, req, options).await
    }

    /// Forwards the call to the implementation provided by `T`.
    async fn update(
        &self,
        req: crate::model::SqlUsersUpdateRequest,
        options: crate::RequestOptions,
    ) -> crate::Result<crate::Response<crate::model::Operation>> {
        T::update(self, req, options).await
    }
}