// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See License.txt in the project root for license information.
// Code generated by Microsoft (R) AutoRest Code Generator. DO NOT EDIT.
// Changes may cause incorrect behavior and will be lost if the code is regenerated.

package fake

import (
	"errors"
	"fmt"
	"github.com/Azure/azure-sdk-for-go/sdk/azcore/runtime"
	"net/http"
	"strings"
	"sync"
)

// ServerFactory is a fake server for instances of the armapimanagement.ClientFactory type.
type ServerFactory struct {
	// APIServer contains the fakes for client APIClient
	APIServer APIServer

	// APIDiagnosticServer contains the fakes for client APIDiagnosticClient
	APIDiagnosticServer APIDiagnosticServer

	// APIExportServer contains the fakes for client APIExportClient
	APIExportServer APIExportServer

	// APIGatewayServer contains the fakes for client APIGatewayClient
	APIGatewayServer APIGatewayServer

	// APIGatewayConfigConnectionServer contains the fakes for client APIGatewayConfigConnectionClient
	APIGatewayConfigConnectionServer APIGatewayConfigConnectionServer

	// APIIssueAttachmentServer contains the fakes for client APIIssueAttachmentClient
	APIIssueAttachmentServer APIIssueAttachmentServer

	// APIIssueServer contains the fakes for client APIIssueClient
	APIIssueServer APIIssueServer

	// APIIssueCommentServer contains the fakes for client APIIssueCommentClient
	APIIssueCommentServer APIIssueCommentServer

	// APIOperationServer contains the fakes for client APIOperationClient
	APIOperationServer APIOperationServer

	// APIOperationPolicyServer contains the fakes for client APIOperationPolicyClient
	APIOperationPolicyServer APIOperationPolicyServer

	// APIPolicyServer contains the fakes for client APIPolicyClient
	APIPolicyServer APIPolicyServer

	// APIProductServer contains the fakes for client APIProductClient
	APIProductServer APIProductServer

	// APIReleaseServer contains the fakes for client APIReleaseClient
	APIReleaseServer APIReleaseServer

	// APIRevisionServer contains the fakes for client APIRevisionClient
	APIRevisionServer APIRevisionServer

	// APISchemaServer contains the fakes for client APISchemaClient
	APISchemaServer APISchemaServer

	// APITagDescriptionServer contains the fakes for client APITagDescriptionClient
	APITagDescriptionServer APITagDescriptionServer

	// APIVersionSetServer contains the fakes for client APIVersionSetClient
	APIVersionSetServer APIVersionSetServer

	// APIWikiServer contains the fakes for client APIWikiClient
	APIWikiServer APIWikiServer

	// APIWikisServer contains the fakes for client APIWikisClient
	APIWikisServer APIWikisServer

	// AllPoliciesServer contains the fakes for client AllPoliciesClient
	AllPoliciesServer AllPoliciesServer

	// AuthorizationAccessPolicyServer contains the fakes for client AuthorizationAccessPolicyClient
	AuthorizationAccessPolicyServer AuthorizationAccessPolicyServer

	// AuthorizationServer contains the fakes for client AuthorizationClient
	AuthorizationServer AuthorizationServer

	// AuthorizationLoginLinksServer contains the fakes for client AuthorizationLoginLinksClient
	AuthorizationLoginLinksServer AuthorizationLoginLinksServer

	// AuthorizationProviderServer contains the fakes for client AuthorizationProviderClient
	AuthorizationProviderServer AuthorizationProviderServer

	// AuthorizationServerServer contains the fakes for client AuthorizationServerClient
	AuthorizationServerServer AuthorizationServerServer

	// BackendServer contains the fakes for client BackendClient
	BackendServer BackendServer

	// CacheServer contains the fakes for client CacheClient
	CacheServer CacheServer

	// CertificateServer contains the fakes for client CertificateClient
	CertificateServer CertificateServer

	// Server contains the fakes for client Client
	Server Server

	// ContentItemServer contains the fakes for client ContentItemClient
	ContentItemServer ContentItemServer

	// ContentTypeServer contains the fakes for client ContentTypeClient
	ContentTypeServer ContentTypeServer

	// DelegationSettingsServer contains the fakes for client DelegationSettingsClient
	DelegationSettingsServer DelegationSettingsServer

	// DeletedServicesServer contains the fakes for client DeletedServicesClient
	DeletedServicesServer DeletedServicesServer

	// DiagnosticServer contains the fakes for client DiagnosticClient
	DiagnosticServer DiagnosticServer

	// DocumentationServer contains the fakes for client DocumentationClient
	DocumentationServer DocumentationServer

	// EmailTemplateServer contains the fakes for client EmailTemplateClient
	EmailTemplateServer EmailTemplateServer

	// GatewayAPIServer contains the fakes for client GatewayAPIClient
	GatewayAPIServer GatewayAPIServer

	// GatewayCertificateAuthorityServer contains the fakes for client GatewayCertificateAuthorityClient
	GatewayCertificateAuthorityServer GatewayCertificateAuthorityServer

	// GatewayServer contains the fakes for client GatewayClient
	GatewayServer GatewayServer

	// GatewayHostnameConfigurationServer contains the fakes for client GatewayHostnameConfigurationClient
	GatewayHostnameConfigurationServer GatewayHostnameConfigurationServer

	// GatewaySKUsServer contains the fakes for client GatewaySKUsClient
	GatewaySKUsServer GatewaySKUsServer

	// GlobalSchemaServer contains the fakes for client GlobalSchemaClient
	GlobalSchemaServer GlobalSchemaServer

	// GraphQLAPIResolverServer contains the fakes for client GraphQLAPIResolverClient
	GraphQLAPIResolverServer GraphQLAPIResolverServer

	// GraphQLAPIResolverPolicyServer contains the fakes for client GraphQLAPIResolverPolicyClient
	GraphQLAPIResolverPolicyServer GraphQLAPIResolverPolicyServer

	// GroupServer contains the fakes for client GroupClient
	GroupServer GroupServer

	// GroupUserServer contains the fakes for client GroupUserClient
	GroupUserServer GroupUserServer

	// IdentityProviderServer contains the fakes for client IdentityProviderClient
	IdentityProviderServer IdentityProviderServer

	// IssueServer contains the fakes for client IssueClient
	IssueServer IssueServer

	// LoggerServer contains the fakes for client LoggerClient
	LoggerServer LoggerServer

	// NamedValueServer contains the fakes for client NamedValueClient
	NamedValueServer NamedValueServer

	// NetworkStatusServer contains the fakes for client NetworkStatusClient
	NetworkStatusServer NetworkStatusServer

	// NotificationServer contains the fakes for client NotificationClient
	NotificationServer NotificationServer

	// NotificationRecipientEmailServer contains the fakes for client NotificationRecipientEmailClient
	NotificationRecipientEmailServer NotificationRecipientEmailServer

	// NotificationRecipientUserServer contains the fakes for client NotificationRecipientUserClient
	NotificationRecipientUserServer NotificationRecipientUserServer

	// OpenIDConnectProviderServer contains the fakes for client OpenIDConnectProviderClient
	OpenIDConnectProviderServer OpenIDConnectProviderServer

	// OperationServer contains the fakes for client OperationClient
	OperationServer OperationServer

	// OperationStatusServer contains the fakes for client OperationStatusClient
	OperationStatusServer OperationStatusServer

	// OperationsServer contains the fakes for client OperationsClient
	OperationsServer OperationsServer

	// OperationsResultsServer contains the fakes for client OperationsResultsClient
	OperationsResultsServer OperationsResultsServer

	// OutboundNetworkDependenciesEndpointsServer contains the fakes for client OutboundNetworkDependenciesEndpointsClient
	OutboundNetworkDependenciesEndpointsServer OutboundNetworkDependenciesEndpointsServer

	// PolicyServer contains the fakes for client PolicyClient
	PolicyServer PolicyServer

	// PolicyDescriptionServer contains the fakes for client PolicyDescriptionClient
	PolicyDescriptionServer PolicyDescriptionServer

	// PolicyFragmentServer contains the fakes for client PolicyFragmentClient
	PolicyFragmentServer PolicyFragmentServer

	// PolicyRestrictionServer contains the fakes for client PolicyRestrictionClient
	PolicyRestrictionServer PolicyRestrictionServer

	// PolicyRestrictionValidationsServer contains the fakes for client PolicyRestrictionValidationsClient
	PolicyRestrictionValidationsServer PolicyRestrictionValidationsServer

	// PortalConfigServer contains the fakes for client PortalConfigClient
	PortalConfigServer PortalConfigServer

	// PortalRevisionServer contains the fakes for client PortalRevisionClient
	PortalRevisionServer PortalRevisionServer

	// PortalSettingsServer contains the fakes for client PortalSettingsClient
	PortalSettingsServer PortalSettingsServer

	// PrivateEndpointConnectionServer contains the fakes for client PrivateEndpointConnectionClient
	PrivateEndpointConnectionServer PrivateEndpointConnectionServer

	// ProductAPIServer contains the fakes for client ProductAPIClient
	ProductAPIServer ProductAPIServer

	// ProductAPILinkServer contains the fakes for client ProductAPILinkClient
	ProductAPILinkServer ProductAPILinkServer

	// ProductServer contains the fakes for client ProductClient
	ProductServer ProductServer

	// ProductGroupServer contains the fakes for client ProductGroupClient
	ProductGroupServer ProductGroupServer

	// ProductGroupLinkServer contains the fakes for client ProductGroupLinkClient
	ProductGroupLinkServer ProductGroupLinkServer

	// ProductPolicyServer contains the fakes for client ProductPolicyClient
	ProductPolicyServer ProductPolicyServer

	// ProductSubscriptionsServer contains the fakes for client ProductSubscriptionsClient
	ProductSubscriptionsServer ProductSubscriptionsServer

	// ProductWikiServer contains the fakes for client ProductWikiClient
	ProductWikiServer ProductWikiServer

	// ProductWikisServer contains the fakes for client ProductWikisClient
	ProductWikisServer ProductWikisServer

	// QuotaByCounterKeysServer contains the fakes for client QuotaByCounterKeysClient
	QuotaByCounterKeysServer QuotaByCounterKeysServer

	// QuotaByPeriodKeysServer contains the fakes for client QuotaByPeriodKeysClient
	QuotaByPeriodKeysServer QuotaByPeriodKeysServer

	// RegionServer contains the fakes for client RegionClient
	RegionServer RegionServer

	// ReportsServer contains the fakes for client ReportsClient
	ReportsServer ReportsServer

	// SKUsServer contains the fakes for client SKUsClient
	SKUsServer SKUsServer

	// ServiceServer contains the fakes for client ServiceClient
	ServiceServer ServiceServer

	// ServiceSKUsServer contains the fakes for client ServiceSKUsClient
	ServiceSKUsServer ServiceSKUsServer

	// SignInSettingsServer contains the fakes for client SignInSettingsClient
	SignInSettingsServer SignInSettingsServer

	// SignUpSettingsServer contains the fakes for client SignUpSettingsClient
	SignUpSettingsServer SignUpSettingsServer

	// SubscriptionServer contains the fakes for client SubscriptionClient
	SubscriptionServer SubscriptionServer

	// TagAPILinkServer contains the fakes for client TagAPILinkClient
	TagAPILinkServer TagAPILinkServer

	// TagServer contains the fakes for client TagClient
	TagServer TagServer

	// TagOperationLinkServer contains the fakes for client TagOperationLinkClient
	TagOperationLinkServer TagOperationLinkServer

	// TagProductLinkServer contains the fakes for client TagProductLinkClient
	TagProductLinkServer TagProductLinkServer

	// TagResourceServer contains the fakes for client TagResourceClient
	TagResourceServer TagResourceServer

	// TenantAccessServer contains the fakes for client TenantAccessClient
	TenantAccessServer TenantAccessServer

	// TenantAccessGitServer contains the fakes for client TenantAccessGitClient
	TenantAccessGitServer TenantAccessGitServer

	// TenantConfigurationServer contains the fakes for client TenantConfigurationClient
	TenantConfigurationServer TenantConfigurationServer

	// TenantSettingsServer contains the fakes for client TenantSettingsClient
	TenantSettingsServer TenantSettingsServer

	// UserServer contains the fakes for client UserClient
	UserServer UserServer

	// UserConfirmationPasswordServer contains the fakes for client UserConfirmationPasswordClient
	UserConfirmationPasswordServer UserConfirmationPasswordServer

	// UserGroupServer contains the fakes for client UserGroupClient
	UserGroupServer UserGroupServer

	// UserIdentitiesServer contains the fakes for client UserIdentitiesClient
	UserIdentitiesServer UserIdentitiesServer

	// UserSubscriptionServer contains the fakes for client UserSubscriptionClient
	UserSubscriptionServer UserSubscriptionServer

	// WorkspaceAPIServer contains the fakes for client WorkspaceAPIClient
	WorkspaceAPIServer WorkspaceAPIServer

	// WorkspaceAPIDiagnosticServer contains the fakes for client WorkspaceAPIDiagnosticClient
	WorkspaceAPIDiagnosticServer WorkspaceAPIDiagnosticServer

	// WorkspaceAPIExportServer contains the fakes for client WorkspaceAPIExportClient
	WorkspaceAPIExportServer WorkspaceAPIExportServer

	// WorkspaceAPIOperationServer contains the fakes for client WorkspaceAPIOperationClient
	WorkspaceAPIOperationServer WorkspaceAPIOperationServer

	// WorkspaceAPIOperationPolicyServer contains the fakes for client WorkspaceAPIOperationPolicyClient
	WorkspaceAPIOperationPolicyServer WorkspaceAPIOperationPolicyServer

	// WorkspaceAPIPolicyServer contains the fakes for client WorkspaceAPIPolicyClient
	WorkspaceAPIPolicyServer WorkspaceAPIPolicyServer

	// WorkspaceAPIReleaseServer contains the fakes for client WorkspaceAPIReleaseClient
	WorkspaceAPIReleaseServer WorkspaceAPIReleaseServer

	// WorkspaceAPIRevisionServer contains the fakes for client WorkspaceAPIRevisionClient
	WorkspaceAPIRevisionServer WorkspaceAPIRevisionServer

	// WorkspaceAPISchemaServer contains the fakes for client WorkspaceAPISchemaClient
	WorkspaceAPISchemaServer WorkspaceAPISchemaServer

	// WorkspaceAPIVersionSetServer contains the fakes for client WorkspaceAPIVersionSetClient
	WorkspaceAPIVersionSetServer WorkspaceAPIVersionSetServer

	// WorkspaceBackendServer contains the fakes for client WorkspaceBackendClient
	WorkspaceBackendServer WorkspaceBackendServer

	// WorkspaceCertificateServer contains the fakes for client WorkspaceCertificateClient
	WorkspaceCertificateServer WorkspaceCertificateServer

	// WorkspaceServer contains the fakes for client WorkspaceClient
	WorkspaceServer WorkspaceServer

	// WorkspaceDiagnosticServer contains the fakes for client WorkspaceDiagnosticClient
	WorkspaceDiagnosticServer WorkspaceDiagnosticServer

	// WorkspaceGlobalSchemaServer contains the fakes for client WorkspaceGlobalSchemaClient
	WorkspaceGlobalSchemaServer WorkspaceGlobalSchemaServer

	// WorkspaceGroupServer contains the fakes for client WorkspaceGroupClient
	WorkspaceGroupServer WorkspaceGroupServer

	// WorkspaceGroupUserServer contains the fakes for client WorkspaceGroupUserClient
	WorkspaceGroupUserServer WorkspaceGroupUserServer

	// WorkspaceLinkServer contains the fakes for client WorkspaceLinkClient
	WorkspaceLinkServer WorkspaceLinkServer

	// WorkspaceLinksServer contains the fakes for client WorkspaceLinksClient
	WorkspaceLinksServer WorkspaceLinksServer

	// WorkspaceLoggerServer contains the fakes for client WorkspaceLoggerClient
	WorkspaceLoggerServer WorkspaceLoggerServer

	// WorkspaceNamedValueServer contains the fakes for client WorkspaceNamedValueClient
	WorkspaceNamedValueServer WorkspaceNamedValueServer

	// WorkspaceNotificationServer contains the fakes for client WorkspaceNotificationClient
	WorkspaceNotificationServer WorkspaceNotificationServer

	// WorkspaceNotificationRecipientEmailServer contains the fakes for client WorkspaceNotificationRecipientEmailClient
	WorkspaceNotificationRecipientEmailServer WorkspaceNotificationRecipientEmailServer

	// WorkspaceNotificationRecipientUserServer contains the fakes for client WorkspaceNotificationRecipientUserClient
	WorkspaceNotificationRecipientUserServer WorkspaceNotificationRecipientUserServer

	// WorkspacePolicyServer contains the fakes for client WorkspacePolicyClient
	WorkspacePolicyServer WorkspacePolicyServer

	// WorkspacePolicyFragmentServer contains the fakes for client WorkspacePolicyFragmentClient
	WorkspacePolicyFragmentServer WorkspacePolicyFragmentServer

	// WorkspaceProductAPILinkServer contains the fakes for client WorkspaceProductAPILinkClient
	WorkspaceProductAPILinkServer WorkspaceProductAPILinkServer

	// WorkspaceProductServer contains the fakes for client WorkspaceProductClient
	WorkspaceProductServer WorkspaceProductServer

	// WorkspaceProductGroupLinkServer contains the fakes for client WorkspaceProductGroupLinkClient
	WorkspaceProductGroupLinkServer WorkspaceProductGroupLinkServer

	// WorkspaceProductPolicyServer contains the fakes for client WorkspaceProductPolicyClient
	WorkspaceProductPolicyServer WorkspaceProductPolicyServer

	// WorkspaceSubscriptionServer contains the fakes for client WorkspaceSubscriptionClient
	WorkspaceSubscriptionServer WorkspaceSubscriptionServer

	// WorkspaceTagAPILinkServer contains the fakes for client WorkspaceTagAPILinkClient
	WorkspaceTagAPILinkServer WorkspaceTagAPILinkServer

	// WorkspaceTagServer contains the fakes for client WorkspaceTagClient
	WorkspaceTagServer WorkspaceTagServer

	// WorkspaceTagOperationLinkServer contains the fakes for client WorkspaceTagOperationLinkClient
	WorkspaceTagOperationLinkServer WorkspaceTagOperationLinkServer

	// WorkspaceTagProductLinkServer contains the fakes for client WorkspaceTagProductLinkClient
	WorkspaceTagProductLinkServer WorkspaceTagProductLinkServer
}

// NewServerFactoryTransport creates a new instance of ServerFactoryTransport with the provided implementation.
// The returned ServerFactoryTransport instance is connected to an instance of armapimanagement.ClientFactory via the
// azcore.ClientOptions.Transporter field in the client's constructor parameters.
func NewServerFactoryTransport(srv *ServerFactory) *ServerFactoryTransport {
	return &ServerFactoryTransport{
		srv: srv,
	}
}

// ServerFactoryTransport connects instances of armapimanagement.ClientFactory to instances of ServerFactory.
// Don't use this type directly, use NewServerFactoryTransport instead.
type ServerFactoryTransport struct {
	srv                                          *ServerFactory
	trMu                                         sync.Mutex
	trAPIServer                                  *APIServerTransport
	trAPIDiagnosticServer                        *APIDiagnosticServerTransport
	trAPIExportServer                            *APIExportServerTransport
	trAPIGatewayServer                           *APIGatewayServerTransport
	trAPIGatewayConfigConnectionServer           *APIGatewayConfigConnectionServerTransport
	trAPIIssueAttachmentServer                   *APIIssueAttachmentServerTransport
	trAPIIssueServer                             *APIIssueServerTransport
	trAPIIssueCommentServer                      *APIIssueCommentServerTransport
	trAPIOperationServer                         *APIOperationServerTransport
	trAPIOperationPolicyServer                   *APIOperationPolicyServerTransport
	trAPIPolicyServer                            *APIPolicyServerTransport
	trAPIProductServer                           *APIProductServerTransport
	trAPIReleaseServer                           *APIReleaseServerTransport
	trAPIRevisionServer                          *APIRevisionServerTransport
	trAPISchemaServer                            *APISchemaServerTransport
	trAPITagDescriptionServer                    *APITagDescriptionServerTransport
	trAPIVersionSetServer                        *APIVersionSetServerTransport
	trAPIWikiServer                              *APIWikiServerTransport
	trAPIWikisServer                             *APIWikisServerTransport
	trAllPoliciesServer                          *AllPoliciesServerTransport
	trAuthorizationAccessPolicyServer            *AuthorizationAccessPolicyServerTransport
	trAuthorizationServer                        *AuthorizationServerTransport
	trAuthorizationLoginLinksServer              *AuthorizationLoginLinksServerTransport
	trAuthorizationProviderServer                *AuthorizationProviderServerTransport
	trAuthorizationServerServer                  *AuthorizationServerServerTransport
	trBackendServer                              *BackendServerTransport
	trCacheServer                                *CacheServerTransport
	trCertificateServer                          *CertificateServerTransport
	trServer                                     *ServerTransport
	trContentItemServer                          *ContentItemServerTransport
	trContentTypeServer                          *ContentTypeServerTransport
	trDelegationSettingsServer                   *DelegationSettingsServerTransport
	trDeletedServicesServer                      *DeletedServicesServerTransport
	trDiagnosticServer                           *DiagnosticServerTransport
	trDocumentationServer                        *DocumentationServerTransport
	trEmailTemplateServer                        *EmailTemplateServerTransport
	trGatewayAPIServer                           *GatewayAPIServerTransport
	trGatewayCertificateAuthorityServer          *GatewayCertificateAuthorityServerTransport
	trGatewayServer                              *GatewayServerTransport
	trGatewayHostnameConfigurationServer         *GatewayHostnameConfigurationServerTransport
	trGatewaySKUsServer                          *GatewaySKUsServerTransport
	trGlobalSchemaServer                         *GlobalSchemaServerTransport
	trGraphQLAPIResolverServer                   *GraphQLAPIResolverServerTransport
	trGraphQLAPIResolverPolicyServer             *GraphQLAPIResolverPolicyServerTransport
	trGroupServer                                *GroupServerTransport
	trGroupUserServer                            *GroupUserServerTransport
	trIdentityProviderServer                     *IdentityProviderServerTransport
	trIssueServer                                *IssueServerTransport
	trLoggerServer                               *LoggerServerTransport
	trNamedValueServer                           *NamedValueServerTransport
	trNetworkStatusServer                        *NetworkStatusServerTransport
	trNotificationServer                         *NotificationServerTransport
	trNotificationRecipientEmailServer           *NotificationRecipientEmailServerTransport
	trNotificationRecipientUserServer            *NotificationRecipientUserServerTransport
	trOpenIDConnectProviderServer                *OpenIDConnectProviderServerTransport
	trOperationServer                            *OperationServerTransport
	trOperationStatusServer                      *OperationStatusServerTransport
	trOperationsServer                           *OperationsServerTransport
	trOperationsResultsServer                    *OperationsResultsServerTransport
	trOutboundNetworkDependenciesEndpointsServer *OutboundNetworkDependenciesEndpointsServerTransport
	trPolicyServer                               *PolicyServerTransport
	trPolicyDescriptionServer                    *PolicyDescriptionServerTransport
	trPolicyFragmentServer                       *PolicyFragmentServerTransport
	trPolicyRestrictionServer                    *PolicyRestrictionServerTransport
	trPolicyRestrictionValidationsServer         *PolicyRestrictionValidationsServerTransport
	trPortalConfigServer                         *PortalConfigServerTransport
	trPortalRevisionServer                       *PortalRevisionServerTransport
	trPortalSettingsServer                       *PortalSettingsServerTransport
	trPrivateEndpointConnectionServer            *PrivateEndpointConnectionServerTransport
	trProductAPIServer                           *ProductAPIServerTransport
	trProductAPILinkServer                       *ProductAPILinkServerTransport
	trProductServer                              *ProductServerTransport
	trProductGroupServer                         *ProductGroupServerTransport
	trProductGroupLinkServer                     *ProductGroupLinkServerTransport
	trProductPolicyServer                        *ProductPolicyServerTransport
	trProductSubscriptionsServer                 *ProductSubscriptionsServerTransport
	trProductWikiServer                          *ProductWikiServerTransport
	trProductWikisServer                         *ProductWikisServerTransport
	trQuotaByCounterKeysServer                   *QuotaByCounterKeysServerTransport
	trQuotaByPeriodKeysServer                    *QuotaByPeriodKeysServerTransport
	trRegionServer                               *RegionServerTransport
	trReportsServer                              *ReportsServerTransport
	trSKUsServer                                 *SKUsServerTransport
	trServiceServer                              *ServiceServerTransport
	trServiceSKUsServer                          *ServiceSKUsServerTransport
	trSignInSettingsServer                       *SignInSettingsServerTransport
	trSignUpSettingsServer                       *SignUpSettingsServerTransport
	trSubscriptionServer                         *SubscriptionServerTransport
	trTagAPILinkServer                           *TagAPILinkServerTransport
	trTagServer                                  *TagServerTransport
	trTagOperationLinkServer                     *TagOperationLinkServerTransport
	trTagProductLinkServer                       *TagProductLinkServerTransport
	trTagResourceServer                          *TagResourceServerTransport
	trTenantAccessServer                         *TenantAccessServerTransport
	trTenantAccessGitServer                      *TenantAccessGitServerTransport
	trTenantConfigurationServer                  *TenantConfigurationServerTransport
	trTenantSettingsServer                       *TenantSettingsServerTransport
	trUserServer                                 *UserServerTransport
	trUserConfirmationPasswordServer             *UserConfirmationPasswordServerTransport
	trUserGroupServer                            *UserGroupServerTransport
	trUserIdentitiesServer                       *UserIdentitiesServerTransport
	trUserSubscriptionServer                     *UserSubscriptionServerTransport
	trWorkspaceAPIServer                         *WorkspaceAPIServerTransport
	trWorkspaceAPIDiagnosticServer               *WorkspaceAPIDiagnosticServerTransport
	trWorkspaceAPIExportServer                   *WorkspaceAPIExportServerTransport
	trWorkspaceAPIOperationServer                *WorkspaceAPIOperationServerTransport
	trWorkspaceAPIOperationPolicyServer          *WorkspaceAPIOperationPolicyServerTransport
	trWorkspaceAPIPolicyServer                   *WorkspaceAPIPolicyServerTransport
	trWorkspaceAPIReleaseServer                  *WorkspaceAPIReleaseServerTransport
	trWorkspaceAPIRevisionServer                 *WorkspaceAPIRevisionServerTransport
	trWorkspaceAPISchemaServer                   *WorkspaceAPISchemaServerTransport
	trWorkspaceAPIVersionSetServer               *WorkspaceAPIVersionSetServerTransport
	trWorkspaceBackendServer                     *WorkspaceBackendServerTransport
	trWorkspaceCertificateServer                 *WorkspaceCertificateServerTransport
	trWorkspaceServer                            *WorkspaceServerTransport
	trWorkspaceDiagnosticServer                  *WorkspaceDiagnosticServerTransport
	trWorkspaceGlobalSchemaServer                *WorkspaceGlobalSchemaServerTransport
	trWorkspaceGroupServer                       *WorkspaceGroupServerTransport
	trWorkspaceGroupUserServer                   *WorkspaceGroupUserServerTransport
	trWorkspaceLinkServer                        *WorkspaceLinkServerTransport
	trWorkspaceLinksServer                       *WorkspaceLinksServerTransport
	trWorkspaceLoggerServer                      *WorkspaceLoggerServerTransport
	trWorkspaceNamedValueServer                  *WorkspaceNamedValueServerTransport
	trWorkspaceNotificationServer                *WorkspaceNotificationServerTransport
	trWorkspaceNotificationRecipientEmailServer  *WorkspaceNotificationRecipientEmailServerTransport
	trWorkspaceNotificationRecipientUserServer   *WorkspaceNotificationRecipientUserServerTransport
	trWorkspacePolicyServer                      *WorkspacePolicyServerTransport
	trWorkspacePolicyFragmentServer              *WorkspacePolicyFragmentServerTransport
	trWorkspaceProductAPILinkServer              *WorkspaceProductAPILinkServerTransport
	trWorkspaceProductServer                     *WorkspaceProductServerTransport
	trWorkspaceProductGroupLinkServer            *WorkspaceProductGroupLinkServerTransport
	trWorkspaceProductPolicyServer               *WorkspaceProductPolicyServerTransport
	trWorkspaceSubscriptionServer                *WorkspaceSubscriptionServerTransport
	trWorkspaceTagAPILinkServer                  *WorkspaceTagAPILinkServerTransport
	trWorkspaceTagServer                         *WorkspaceTagServerTransport
	trWorkspaceTagOperationLinkServer            *WorkspaceTagOperationLinkServerTransport
	trWorkspaceTagProductLinkServer              *WorkspaceTagProductLinkServerTransport
}

// Do implements the policy.Transporter interface for ServerFactoryTransport.
func (s *ServerFactoryTransport) Do(req *http.Request) (*http.Response, error) {
	rawMethod := req.Context().Value(runtime.CtxAPINameKey{})
	method, ok := rawMethod.(string)
	if !ok {
		return nil, nonRetriableError{errors.New("unable to dispatch request, missing value for CtxAPINameKey")}
	}

	client := method[:strings.Index(method, ".")]
	var resp *http.Response
	var err error

	switch client {
	case "APIClient":
		initServer(s, &s.trAPIServer, func() *APIServerTransport { return NewAPIServerTransport(&s.srv.APIServer) })
		resp, err = s.trAPIServer.Do(req)
	case "APIDiagnosticClient":
		initServer(s, &s.trAPIDiagnosticServer, func() *APIDiagnosticServerTransport {
			return NewAPIDiagnosticServerTransport(&s.srv.APIDiagnosticServer)
		})
		resp, err = s.trAPIDiagnosticServer.Do(req)
	case "APIExportClient":
		initServer(s, &s.trAPIExportServer, func() *APIExportServerTransport { return NewAPIExportServerTransport(&s.srv.APIExportServer) })
		resp, err = s.trAPIExportServer.Do(req)
	case "APIGatewayClient":
		initServer(s, &s.trAPIGatewayServer, func() *APIGatewayServerTransport { return NewAPIGatewayServerTransport(&s.srv.APIGatewayServer) })
		resp, err = s.trAPIGatewayServer.Do(req)
	case "APIGatewayConfigConnectionClient":
		initServer(s, &s.trAPIGatewayConfigConnectionServer, func() *APIGatewayConfigConnectionServerTransport {
			return NewAPIGatewayConfigConnectionServerTransport(&s.srv.APIGatewayConfigConnectionServer)
		})
		resp, err = s.trAPIGatewayConfigConnectionServer.Do(req)
	case "APIIssueAttachmentClient":
		initServer(s, &s.trAPIIssueAttachmentServer, func() *APIIssueAttachmentServerTransport {
			return NewAPIIssueAttachmentServerTransport(&s.srv.APIIssueAttachmentServer)
		})
		resp, err = s.trAPIIssueAttachmentServer.Do(req)
	case "APIIssueClient":
		initServer(s, &s.trAPIIssueServer, func() *APIIssueServerTransport { return NewAPIIssueServerTransport(&s.srv.APIIssueServer) })
		resp, err = s.trAPIIssueServer.Do(req)
	case "APIIssueCommentClient":
		initServer(s, &s.trAPIIssueCommentServer, func() *APIIssueCommentServerTransport {
			return NewAPIIssueCommentServerTransport(&s.srv.APIIssueCommentServer)
		})
		resp, err = s.trAPIIssueCommentServer.Do(req)
	case "APIOperationClient":
		initServer(s, &s.trAPIOperationServer, func() *APIOperationServerTransport { return NewAPIOperationServerTransport(&s.srv.APIOperationServer) })
		resp, err = s.trAPIOperationServer.Do(req)
	case "APIOperationPolicyClient":
		initServer(s, &s.trAPIOperationPolicyServer, func() *APIOperationPolicyServerTransport {
			return NewAPIOperationPolicyServerTransport(&s.srv.APIOperationPolicyServer)
		})
		resp, err = s.trAPIOperationPolicyServer.Do(req)
	case "APIPolicyClient":
		initServer(s, &s.trAPIPolicyServer, func() *APIPolicyServerTransport { return NewAPIPolicyServerTransport(&s.srv.APIPolicyServer) })
		resp, err = s.trAPIPolicyServer.Do(req)
	case "APIProductClient":
		initServer(s, &s.trAPIProductServer, func() *APIProductServerTransport { return NewAPIProductServerTransport(&s.srv.APIProductServer) })
		resp, err = s.trAPIProductServer.Do(req)
	case "APIReleaseClient":
		initServer(s, &s.trAPIReleaseServer, func() *APIReleaseServerTransport { return NewAPIReleaseServerTransport(&s.srv.APIReleaseServer) })
		resp, err = s.trAPIReleaseServer.Do(req)
	case "APIRevisionClient":
		initServer(s, &s.trAPIRevisionServer, func() *APIRevisionServerTransport { return NewAPIRevisionServerTransport(&s.srv.APIRevisionServer) })
		resp, err = s.trAPIRevisionServer.Do(req)
	case "APISchemaClient":
		initServer(s, &s.trAPISchemaServer, func() *APISchemaServerTransport { return NewAPISchemaServerTransport(&s.srv.APISchemaServer) })
		resp, err = s.trAPISchemaServer.Do(req)
	case "APITagDescriptionClient":
		initServer(s, &s.trAPITagDescriptionServer, func() *APITagDescriptionServerTransport {
			return NewAPITagDescriptionServerTransport(&s.srv.APITagDescriptionServer)
		})
		resp, err = s.trAPITagDescriptionServer.Do(req)
	case "APIVersionSetClient":
		initServer(s, &s.trAPIVersionSetServer, func() *APIVersionSetServerTransport {
			return NewAPIVersionSetServerTransport(&s.srv.APIVersionSetServer)
		})
		resp, err = s.trAPIVersionSetServer.Do(req)
	case "APIWikiClient":
		initServer(s, &s.trAPIWikiServer, func() *APIWikiServerTransport { return NewAPIWikiServerTransport(&s.srv.APIWikiServer) })
		resp, err = s.trAPIWikiServer.Do(req)
	case "APIWikisClient":
		initServer(s, &s.trAPIWikisServer, func() *APIWikisServerTransport { return NewAPIWikisServerTransport(&s.srv.APIWikisServer) })
		resp, err = s.trAPIWikisServer.Do(req)
	case "AllPoliciesClient":
		initServer(s, &s.trAllPoliciesServer, func() *AllPoliciesServerTransport { return NewAllPoliciesServerTransport(&s.srv.AllPoliciesServer) })
		resp, err = s.trAllPoliciesServer.Do(req)
	case "AuthorizationAccessPolicyClient":
		initServer(s, &s.trAuthorizationAccessPolicyServer, func() *AuthorizationAccessPolicyServerTransport {
			return NewAuthorizationAccessPolicyServerTransport(&s.srv.AuthorizationAccessPolicyServer)
		})
		resp, err = s.trAuthorizationAccessPolicyServer.Do(req)
	case "AuthorizationClient":
		initServer(s, &s.trAuthorizationServer, func() *AuthorizationServerTransport {
			return NewAuthorizationServerTransport(&s.srv.AuthorizationServer)
		})
		resp, err = s.trAuthorizationServer.Do(req)
	case "AuthorizationLoginLinksClient":
		initServer(s, &s.trAuthorizationLoginLinksServer, func() *AuthorizationLoginLinksServerTransport {
			return NewAuthorizationLoginLinksServerTransport(&s.srv.AuthorizationLoginLinksServer)
		})
		resp, err = s.trAuthorizationLoginLinksServer.Do(req)
	case "AuthorizationProviderClient":
		initServer(s, &s.trAuthorizationProviderServer, func() *AuthorizationProviderServerTransport {
			return NewAuthorizationProviderServerTransport(&s.srv.AuthorizationProviderServer)
		})
		resp, err = s.trAuthorizationProviderServer.Do(req)
	case "AuthorizationServerClient":
		initServer(s, &s.trAuthorizationServerServer, func() *AuthorizationServerServerTransport {
			return NewAuthorizationServerServerTransport(&s.srv.AuthorizationServerServer)
		})
		resp, err = s.trAuthorizationServerServer.Do(req)
	case "BackendClient":
		initServer(s, &s.trBackendServer, func() *BackendServerTransport { return NewBackendServerTransport(&s.srv.BackendServer) })
		resp, err = s.trBackendServer.Do(req)
	case "CacheClient":
		initServer(s, &s.trCacheServer, func() *CacheServerTransport { return NewCacheServerTransport(&s.srv.CacheServer) })
		resp, err = s.trCacheServer.Do(req)
	case "CertificateClient":
		initServer(s, &s.trCertificateServer, func() *CertificateServerTransport { return NewCertificateServerTransport(&s.srv.CertificateServer) })
		resp, err = s.trCertificateServer.Do(req)
	case "Client":
		initServer(s, &s.trServer, func() *ServerTransport { return NewServerTransport(&s.srv.Server) })
		resp, err = s.trServer.Do(req)
	case "ContentItemClient":
		initServer(s, &s.trContentItemServer, func() *ContentItemServerTransport { return NewContentItemServerTransport(&s.srv.ContentItemServer) })
		resp, err = s.trContentItemServer.Do(req)
	case "ContentTypeClient":
		initServer(s, &s.trContentTypeServer, func() *ContentTypeServerTransport { return NewContentTypeServerTransport(&s.srv.ContentTypeServer) })
		resp, err = s.trContentTypeServer.Do(req)
	case "DelegationSettingsClient":
		initServer(s, &s.trDelegationSettingsServer, func() *DelegationSettingsServerTransport {
			return NewDelegationSettingsServerTransport(&s.srv.DelegationSettingsServer)
		})
		resp, err = s.trDelegationSettingsServer.Do(req)
	case "DeletedServicesClient":
		initServer(s, &s.trDeletedServicesServer, func() *DeletedServicesServerTransport {
			return NewDeletedServicesServerTransport(&s.srv.DeletedServicesServer)
		})
		resp, err = s.trDeletedServicesServer.Do(req)
	case "DiagnosticClient":
		initServer(s, &s.trDiagnosticServer, func() *DiagnosticServerTransport { return NewDiagnosticServerTransport(&s.srv.DiagnosticServer) })
		resp, err = s.trDiagnosticServer.Do(req)
	case "DocumentationClient":
		initServer(s, &s.trDocumentationServer, func() *DocumentationServerTransport {
			return NewDocumentationServerTransport(&s.srv.DocumentationServer)
		})
		resp, err = s.trDocumentationServer.Do(req)
	case "EmailTemplateClient":
		initServer(s, &s.trEmailTemplateServer, func() *EmailTemplateServerTransport {
			return NewEmailTemplateServerTransport(&s.srv.EmailTemplateServer)
		})
		resp, err = s.trEmailTemplateServer.Do(req)
	case "GatewayAPIClient":
		initServer(s, &s.trGatewayAPIServer, func() *GatewayAPIServerTransport { return NewGatewayAPIServerTransport(&s.srv.GatewayAPIServer) })
		resp, err = s.trGatewayAPIServer.Do(req)
	case "GatewayCertificateAuthorityClient":
		initServer(s, &s.trGatewayCertificateAuthorityServer, func() *GatewayCertificateAuthorityServerTransport {
			return NewGatewayCertificateAuthorityServerTransport(&s.srv.GatewayCertificateAuthorityServer)
		})
		resp, err = s.trGatewayCertificateAuthorityServer.Do(req)
	case "GatewayClient":
		initServer(s, &s.trGatewayServer, func() *GatewayServerTransport { return NewGatewayServerTransport(&s.srv.GatewayServer) })
		resp, err = s.trGatewayServer.Do(req)
	case "GatewayHostnameConfigurationClient":
		initServer(s, &s.trGatewayHostnameConfigurationServer, func() *GatewayHostnameConfigurationServerTransport {
			return NewGatewayHostnameConfigurationServerTransport(&s.srv.GatewayHostnameConfigurationServer)
		})
		resp, err = s.trGatewayHostnameConfigurationServer.Do(req)
	case "GatewaySKUsClient":
		initServer(s, &s.trGatewaySKUsServer, func() *GatewaySKUsServerTransport { return NewGatewaySKUsServerTransport(&s.srv.GatewaySKUsServer) })
		resp, err = s.trGatewaySKUsServer.Do(req)
	case "GlobalSchemaClient":
		initServer(s, &s.trGlobalSchemaServer, func() *GlobalSchemaServerTransport { return NewGlobalSchemaServerTransport(&s.srv.GlobalSchemaServer) })
		resp, err = s.trGlobalSchemaServer.Do(req)
	case "GraphQLAPIResolverClient":
		initServer(s, &s.trGraphQLAPIResolverServer, func() *GraphQLAPIResolverServerTransport {
			return NewGraphQLAPIResolverServerTransport(&s.srv.GraphQLAPIResolverServer)
		})
		resp, err = s.trGraphQLAPIResolverServer.Do(req)
	case "GraphQLAPIResolverPolicyClient":
		initServer(s, &s.trGraphQLAPIResolverPolicyServer, func() *GraphQLAPIResolverPolicyServerTransport {
			return NewGraphQLAPIResolverPolicyServerTransport(&s.srv.GraphQLAPIResolverPolicyServer)
		})
		resp, err = s.trGraphQLAPIResolverPolicyServer.Do(req)
	case "GroupClient":
		initServer(s, &s.trGroupServer, func() *GroupServerTransport { return NewGroupServerTransport(&s.srv.GroupServer) })
		resp, err = s.trGroupServer.Do(req)
	case "GroupUserClient":
		initServer(s, &s.trGroupUserServer, func() *GroupUserServerTransport { return NewGroupUserServerTransport(&s.srv.GroupUserServer) })
		resp, err = s.trGroupUserServer.Do(req)
	case "IdentityProviderClient":
		initServer(s, &s.trIdentityProviderServer, func() *IdentityProviderServerTransport {
			return NewIdentityProviderServerTransport(&s.srv.IdentityProviderServer)
		})
		resp, err = s.trIdentityProviderServer.Do(req)
	case "IssueClient":
		initServer(s, &s.trIssueServer, func() *IssueServerTransport { return NewIssueServerTransport(&s.srv.IssueServer) })
		resp, err = s.trIssueServer.Do(req)
	case "LoggerClient":
		initServer(s, &s.trLoggerServer, func() *LoggerServerTransport { return NewLoggerServerTransport(&s.srv.LoggerServer) })
		resp, err = s.trLoggerServer.Do(req)
	case "NamedValueClient":
		initServer(s, &s.trNamedValueServer, func() *NamedValueServerTransport { return NewNamedValueServerTransport(&s.srv.NamedValueServer) })
		resp, err = s.trNamedValueServer.Do(req)
	case "NetworkStatusClient":
		initServer(s, &s.trNetworkStatusServer, func() *NetworkStatusServerTransport {
			return NewNetworkStatusServerTransport(&s.srv.NetworkStatusServer)
		})
		resp, err = s.trNetworkStatusServer.Do(req)
	case "NotificationClient":
		initServer(s, &s.trNotificationServer, func() *NotificationServerTransport { return NewNotificationServerTransport(&s.srv.NotificationServer) })
		resp, err = s.trNotificationServer.Do(req)
	case "NotificationRecipientEmailClient":
		initServer(s, &s.trNotificationRecipientEmailServer, func() *NotificationRecipientEmailServerTransport {
			return NewNotificationRecipientEmailServerTransport(&s.srv.NotificationRecipientEmailServer)
		})
		resp, err = s.trNotificationRecipientEmailServer.Do(req)
	case "NotificationRecipientUserClient":
		initServer(s, &s.trNotificationRecipientUserServer, func() *NotificationRecipientUserServerTransport {
			return NewNotificationRecipientUserServerTransport(&s.srv.NotificationRecipientUserServer)
		})
		resp, err = s.trNotificationRecipientUserServer.Do(req)
	case "OpenIDConnectProviderClient":
		initServer(s, &s.trOpenIDConnectProviderServer, func() *OpenIDConnectProviderServerTransport {
			return NewOpenIDConnectProviderServerTransport(&s.srv.OpenIDConnectProviderServer)
		})
		resp, err = s.trOpenIDConnectProviderServer.Do(req)
	case "OperationClient":
		initServer(s, &s.trOperationServer, func() *OperationServerTransport { return NewOperationServerTransport(&s.srv.OperationServer) })
		resp, err = s.trOperationServer.Do(req)
	case "OperationStatusClient":
		initServer(s, &s.trOperationStatusServer, func() *OperationStatusServerTransport {
			return NewOperationStatusServerTransport(&s.srv.OperationStatusServer)
		})
		resp, err = s.trOperationStatusServer.Do(req)
	case "OperationsClient":
		initServer(s, &s.trOperationsServer, func() *OperationsServerTransport { return NewOperationsServerTransport(&s.srv.OperationsServer) })
		resp, err = s.trOperationsServer.Do(req)
	case "OperationsResultsClient":
		initServer(s, &s.trOperationsResultsServer, func() *OperationsResultsServerTransport {
			return NewOperationsResultsServerTransport(&s.srv.OperationsResultsServer)
		})
		resp, err = s.trOperationsResultsServer.Do(req)
	case "OutboundNetworkDependenciesEndpointsClient":
		initServer(s, &s.trOutboundNetworkDependenciesEndpointsServer, func() *OutboundNetworkDependenciesEndpointsServerTransport {
			return NewOutboundNetworkDependenciesEndpointsServerTransport(&s.srv.OutboundNetworkDependenciesEndpointsServer)
		})
		resp, err = s.trOutboundNetworkDependenciesEndpointsServer.Do(req)
	case "PolicyClient":
		initServer(s, &s.trPolicyServer, func() *PolicyServerTransport { return NewPolicyServerTransport(&s.srv.PolicyServer) })
		resp, err = s.trPolicyServer.Do(req)
	case "PolicyDescriptionClient":
		initServer(s, &s.trPolicyDescriptionServer, func() *PolicyDescriptionServerTransport {
			return NewPolicyDescriptionServerTransport(&s.srv.PolicyDescriptionServer)
		})
		resp, err = s.trPolicyDescriptionServer.Do(req)
	case "PolicyFragmentClient":
		initServer(s, &s.trPolicyFragmentServer, func() *PolicyFragmentServerTransport {
			return NewPolicyFragmentServerTransport(&s.srv.PolicyFragmentServer)
		})
		resp, err = s.trPolicyFragmentServer.Do(req)
	case "PolicyRestrictionClient":
		initServer(s, &s.trPolicyRestrictionServer, func() *PolicyRestrictionServerTransport {
			return NewPolicyRestrictionServerTransport(&s.srv.PolicyRestrictionServer)
		})
		resp, err = s.trPolicyRestrictionServer.Do(req)
	case "PolicyRestrictionValidationsClient":
		initServer(s, &s.trPolicyRestrictionValidationsServer, func() *PolicyRestrictionValidationsServerTransport {
			return NewPolicyRestrictionValidationsServerTransport(&s.srv.PolicyRestrictionValidationsServer)
		})
		resp, err = s.trPolicyRestrictionValidationsServer.Do(req)
	case "PortalConfigClient":
		initServer(s, &s.trPortalConfigServer, func() *PortalConfigServerTransport { return NewPortalConfigServerTransport(&s.srv.PortalConfigServer) })
		resp, err = s.trPortalConfigServer.Do(req)
	case "PortalRevisionClient":
		initServer(s, &s.trPortalRevisionServer, func() *PortalRevisionServerTransport {
			return NewPortalRevisionServerTransport(&s.srv.PortalRevisionServer)
		})
		resp, err = s.trPortalRevisionServer.Do(req)
	case "PortalSettingsClient":
		initServer(s, &s.trPortalSettingsServer, func() *PortalSettingsServerTransport {
			return NewPortalSettingsServerTransport(&s.srv.PortalSettingsServer)
		})
		resp, err = s.trPortalSettingsServer.Do(req)
	case "PrivateEndpointConnectionClient":
		initServer(s, &s.trPrivateEndpointConnectionServer, func() *PrivateEndpointConnectionServerTransport {
			return NewPrivateEndpointConnectionServerTransport(&s.srv.PrivateEndpointConnectionServer)
		})
		resp, err = s.trPrivateEndpointConnectionServer.Do(req)
	case "ProductAPIClient":
		initServer(s, &s.trProductAPIServer, func() *ProductAPIServerTransport { return NewProductAPIServerTransport(&s.srv.ProductAPIServer) })
		resp, err = s.trProductAPIServer.Do(req)
	case "ProductAPILinkClient":
		initServer(s, &s.trProductAPILinkServer, func() *ProductAPILinkServerTransport {
			return NewProductAPILinkServerTransport(&s.srv.ProductAPILinkServer)
		})
		resp, err = s.trProductAPILinkServer.Do(req)
	case "ProductClient":
		initServer(s, &s.trProductServer, func() *ProductServerTransport { return NewProductServerTransport(&s.srv.ProductServer) })
		resp, err = s.trProductServer.Do(req)
	case "ProductGroupClient":
		initServer(s, &s.trProductGroupServer, func() *ProductGroupServerTransport { return NewProductGroupServerTransport(&s.srv.ProductGroupServer) })
		resp, err = s.trProductGroupServer.Do(req)
	case "ProductGroupLinkClient":
		initServer(s, &s.trProductGroupLinkServer, func() *ProductGroupLinkServerTransport {
			return NewProductGroupLinkServerTransport(&s.srv.ProductGroupLinkServer)
		})
		resp, err = s.trProductGroupLinkServer.Do(req)
	case "ProductPolicyClient":
		initServer(s, &s.trProductPolicyServer, func() *ProductPolicyServerTransport {
			return NewProductPolicyServerTransport(&s.srv.ProductPolicyServer)
		})
		resp, err = s.trProductPolicyServer.Do(req)
	case "ProductSubscriptionsClient":
		initServer(s, &s.trProductSubscriptionsServer, func() *ProductSubscriptionsServerTransport {
			return NewProductSubscriptionsServerTransport(&s.srv.ProductSubscriptionsServer)
		})
		resp, err = s.trProductSubscriptionsServer.Do(req)
	case "ProductWikiClient":
		initServer(s, &s.trProductWikiServer, func() *ProductWikiServerTransport { return NewProductWikiServerTransport(&s.srv.ProductWikiServer) })
		resp, err = s.trProductWikiServer.Do(req)
	case "ProductWikisClient":
		initServer(s, &s.trProductWikisServer, func() *ProductWikisServerTransport { return NewProductWikisServerTransport(&s.srv.ProductWikisServer) })
		resp, err = s.trProductWikisServer.Do(req)
	case "QuotaByCounterKeysClient":
		initServer(s, &s.trQuotaByCounterKeysServer, func() *QuotaByCounterKeysServerTransport {
			return NewQuotaByCounterKeysServerTransport(&s.srv.QuotaByCounterKeysServer)
		})
		resp, err = s.trQuotaByCounterKeysServer.Do(req)
	case "QuotaByPeriodKeysClient":
		initServer(s, &s.trQuotaByPeriodKeysServer, func() *QuotaByPeriodKeysServerTransport {
			return NewQuotaByPeriodKeysServerTransport(&s.srv.QuotaByPeriodKeysServer)
		})
		resp, err = s.trQuotaByPeriodKeysServer.Do(req)
	case "RegionClient":
		initServer(s, &s.trRegionServer, func() *RegionServerTransport { return NewRegionServerTransport(&s.srv.RegionServer) })
		resp, err = s.trRegionServer.Do(req)
	case "ReportsClient":
		initServer(s, &s.trReportsServer, func() *ReportsServerTransport { return NewReportsServerTransport(&s.srv.ReportsServer) })
		resp, err = s.trReportsServer.Do(req)
	case "SKUsClient":
		initServer(s, &s.trSKUsServer, func() *SKUsServerTransport { return NewSKUsServerTransport(&s.srv.SKUsServer) })
		resp, err = s.trSKUsServer.Do(req)
	case "ServiceClient":
		initServer(s, &s.trServiceServer, func() *ServiceServerTransport { return NewServiceServerTransport(&s.srv.ServiceServer) })
		resp, err = s.trServiceServer.Do(req)
	case "ServiceSKUsClient":
		initServer(s, &s.trServiceSKUsServer, func() *ServiceSKUsServerTransport { return NewServiceSKUsServerTransport(&s.srv.ServiceSKUsServer) })
		resp, err = s.trServiceSKUsServer.Do(req)
	case "SignInSettingsClient":
		initServer(s, &s.trSignInSettingsServer, func() *SignInSettingsServerTransport {
			return NewSignInSettingsServerTransport(&s.srv.SignInSettingsServer)
		})
		resp, err = s.trSignInSettingsServer.Do(req)
	case "SignUpSettingsClient":
		initServer(s, &s.trSignUpSettingsServer, func() *SignUpSettingsServerTransport {
			return NewSignUpSettingsServerTransport(&s.srv.SignUpSettingsServer)
		})
		resp, err = s.trSignUpSettingsServer.Do(req)
	case "SubscriptionClient":
		initServer(s, &s.trSubscriptionServer, func() *SubscriptionServerTransport { return NewSubscriptionServerTransport(&s.srv.SubscriptionServer) })
		resp, err = s.trSubscriptionServer.Do(req)
	case "TagAPILinkClient":
		initServer(s, &s.trTagAPILinkServer, func() *TagAPILinkServerTransport { return NewTagAPILinkServerTransport(&s.srv.TagAPILinkServer) })
		resp, err = s.trTagAPILinkServer.Do(req)
	case "TagClient":
		initServer(s, &s.trTagServer, func() *TagServerTransport { return NewTagServerTransport(&s.srv.TagServer) })
		resp, err = s.trTagServer.Do(req)
	case "TagOperationLinkClient":
		initServer(s, &s.trTagOperationLinkServer, func() *TagOperationLinkServerTransport {
			return NewTagOperationLinkServerTransport(&s.srv.TagOperationLinkServer)
		})
		resp, err = s.trTagOperationLinkServer.Do(req)
	case "TagProductLinkClient":
		initServer(s, &s.trTagProductLinkServer, func() *TagProductLinkServerTransport {
			return NewTagProductLinkServerTransport(&s.srv.TagProductLinkServer)
		})
		resp, err = s.trTagProductLinkServer.Do(req)
	case "TagResourceClient":
		initServer(s, &s.trTagResourceServer, func() *TagResourceServerTransport { return NewTagResourceServerTransport(&s.srv.TagResourceServer) })
		resp, err = s.trTagResourceServer.Do(req)
	case "TenantAccessClient":
		initServer(s, &s.trTenantAccessServer, func() *TenantAccessServerTransport { return NewTenantAccessServerTransport(&s.srv.TenantAccessServer) })
		resp, err = s.trTenantAccessServer.Do(req)
	case "TenantAccessGitClient":
		initServer(s, &s.trTenantAccessGitServer, func() *TenantAccessGitServerTransport {
			return NewTenantAccessGitServerTransport(&s.srv.TenantAccessGitServer)
		})
		resp, err = s.trTenantAccessGitServer.Do(req)
	case "TenantConfigurationClient":
		initServer(s, &s.trTenantConfigurationServer, func() *TenantConfigurationServerTransport {
			return NewTenantConfigurationServerTransport(&s.srv.TenantConfigurationServer)
		})
		resp, err = s.trTenantConfigurationServer.Do(req)
	case "TenantSettingsClient":
		initServer(s, &s.trTenantSettingsServer, func() *TenantSettingsServerTransport {
			return NewTenantSettingsServerTransport(&s.srv.TenantSettingsServer)
		})
		resp, err = s.trTenantSettingsServer.Do(req)
	case "UserClient":
		initServer(s, &s.trUserServer, func() *UserServerTransport { return NewUserServerTransport(&s.srv.UserServer) })
		resp, err = s.trUserServer.Do(req)
	case "UserConfirmationPasswordClient":
		initServer(s, &s.trUserConfirmationPasswordServer, func() *UserConfirmationPasswordServerTransport {
			return NewUserConfirmationPasswordServerTransport(&s.srv.UserConfirmationPasswordServer)
		})
		resp, err = s.trUserConfirmationPasswordServer.Do(req)
	case "UserGroupClient":
		initServer(s, &s.trUserGroupServer, func() *UserGroupServerTransport { return NewUserGroupServerTransport(&s.srv.UserGroupServer) })
		resp, err = s.trUserGroupServer.Do(req)
	case "UserIdentitiesClient":
		initServer(s, &s.trUserIdentitiesServer, func() *UserIdentitiesServerTransport {
			return NewUserIdentitiesServerTransport(&s.srv.UserIdentitiesServer)
		})
		resp, err = s.trUserIdentitiesServer.Do(req)
	case "UserSubscriptionClient":
		initServer(s, &s.trUserSubscriptionServer, func() *UserSubscriptionServerTransport {
			return NewUserSubscriptionServerTransport(&s.srv.UserSubscriptionServer)
		})
		resp, err = s.trUserSubscriptionServer.Do(req)
	case "WorkspaceAPIClient":
		initServer(s, &s.trWorkspaceAPIServer, func() *WorkspaceAPIServerTransport { return NewWorkspaceAPIServerTransport(&s.srv.WorkspaceAPIServer) })
		resp, err = s.trWorkspaceAPIServer.Do(req)
	case "WorkspaceAPIDiagnosticClient":
		initServer(s, &s.trWorkspaceAPIDiagnosticServer, func() *WorkspaceAPIDiagnosticServerTransport {
			return NewWorkspaceAPIDiagnosticServerTransport(&s.srv.WorkspaceAPIDiagnosticServer)
		})
		resp, err = s.trWorkspaceAPIDiagnosticServer.Do(req)
	case "WorkspaceAPIExportClient":
		initServer(s, &s.trWorkspaceAPIExportServer, func() *WorkspaceAPIExportServerTransport {
			return NewWorkspaceAPIExportServerTransport(&s.srv.WorkspaceAPIExportServer)
		})
		resp, err = s.trWorkspaceAPIExportServer.Do(req)
	case "WorkspaceAPIOperationClient":
		initServer(s, &s.trWorkspaceAPIOperationServer, func() *WorkspaceAPIOperationServerTransport {
			return NewWorkspaceAPIOperationServerTransport(&s.srv.WorkspaceAPIOperationServer)
		})
		resp, err = s.trWorkspaceAPIOperationServer.Do(req)
	case "WorkspaceAPIOperationPolicyClient":
		initServer(s, &s.trWorkspaceAPIOperationPolicyServer, func() *WorkspaceAPIOperationPolicyServerTransport {
			return NewWorkspaceAPIOperationPolicyServerTransport(&s.srv.WorkspaceAPIOperationPolicyServer)
		})
		resp, err = s.trWorkspaceAPIOperationPolicyServer.Do(req)
	case "WorkspaceAPIPolicyClient":
		initServer(s, &s.trWorkspaceAPIPolicyServer, func() *WorkspaceAPIPolicyServerTransport {
			return NewWorkspaceAPIPolicyServerTransport(&s.srv.WorkspaceAPIPolicyServer)
		})
		resp, err = s.trWorkspaceAPIPolicyServer.Do(req)
	case "WorkspaceAPIReleaseClient":
		initServer(s, &s.trWorkspaceAPIReleaseServer, func() *WorkspaceAPIReleaseServerTransport {
			return NewWorkspaceAPIReleaseServerTransport(&s.srv.WorkspaceAPIReleaseServer)
		})
		resp, err = s.trWorkspaceAPIReleaseServer.Do(req)
	case "WorkspaceAPIRevisionClient":
		initServer(s, &s.trWorkspaceAPIRevisionServer, func() *WorkspaceAPIRevisionServerTransport {
			return NewWorkspaceAPIRevisionServerTransport(&s.srv.WorkspaceAPIRevisionServer)
		})
		resp, err = s.trWorkspaceAPIRevisionServer.Do(req)
	case "WorkspaceAPISchemaClient":
		initServer(s, &s.trWorkspaceAPISchemaServer, func() *WorkspaceAPISchemaServerTransport {
			return NewWorkspaceAPISchemaServerTransport(&s.srv.WorkspaceAPISchemaServer)
		})
		resp, err = s.trWorkspaceAPISchemaServer.Do(req)
	case "WorkspaceAPIVersionSetClient":
		initServer(s, &s.trWorkspaceAPIVersionSetServer, func() *WorkspaceAPIVersionSetServerTransport {
			return NewWorkspaceAPIVersionSetServerTransport(&s.srv.WorkspaceAPIVersionSetServer)
		})
		resp, err = s.trWorkspaceAPIVersionSetServer.Do(req)
	case "WorkspaceBackendClient":
		initServer(s, &s.trWorkspaceBackendServer, func() *WorkspaceBackendServerTransport {
			return NewWorkspaceBackendServerTransport(&s.srv.WorkspaceBackendServer)
		})
		resp, err = s.trWorkspaceBackendServer.Do(req)
	case "WorkspaceCertificateClient":
		initServer(s, &s.trWorkspaceCertificateServer, func() *WorkspaceCertificateServerTransport {
			return NewWorkspaceCertificateServerTransport(&s.srv.WorkspaceCertificateServer)
		})
		resp, err = s.trWorkspaceCertificateServer.Do(req)
	case "WorkspaceClient":
		initServer(s, &s.trWorkspaceServer, func() *WorkspaceServerTransport { return NewWorkspaceServerTransport(&s.srv.WorkspaceServer) })
		resp, err = s.trWorkspaceServer.Do(req)
	case "WorkspaceDiagnosticClient":
		initServer(s, &s.trWorkspaceDiagnosticServer, func() *WorkspaceDiagnosticServerTransport {
			return NewWorkspaceDiagnosticServerTransport(&s.srv.WorkspaceDiagnosticServer)
		})
		resp, err = s.trWorkspaceDiagnosticServer.Do(req)
	case "WorkspaceGlobalSchemaClient":
		initServer(s, &s.trWorkspaceGlobalSchemaServer, func() *WorkspaceGlobalSchemaServerTransport {
			return NewWorkspaceGlobalSchemaServerTransport(&s.srv.WorkspaceGlobalSchemaServer)
		})
		resp, err = s.trWorkspaceGlobalSchemaServer.Do(req)
	case "WorkspaceGroupClient":
		initServer(s, &s.trWorkspaceGroupServer, func() *WorkspaceGroupServerTransport {
			return NewWorkspaceGroupServerTransport(&s.srv.WorkspaceGroupServer)
		})
		resp, err = s.trWorkspaceGroupServer.Do(req)
	case "WorkspaceGroupUserClient":
		initServer(s, &s.trWorkspaceGroupUserServer, func() *WorkspaceGroupUserServerTransport {
			return NewWorkspaceGroupUserServerTransport(&s.srv.WorkspaceGroupUserServer)
		})
		resp, err = s.trWorkspaceGroupUserServer.Do(req)
	case "WorkspaceLinkClient":
		initServer(s, &s.trWorkspaceLinkServer, func() *WorkspaceLinkServerTransport {
			return NewWorkspaceLinkServerTransport(&s.srv.WorkspaceLinkServer)
		})
		resp, err = s.trWorkspaceLinkServer.Do(req)
	case "WorkspaceLinksClient":
		initServer(s, &s.trWorkspaceLinksServer, func() *WorkspaceLinksServerTransport {
			return NewWorkspaceLinksServerTransport(&s.srv.WorkspaceLinksServer)
		})
		resp, err = s.trWorkspaceLinksServer.Do(req)
	case "WorkspaceLoggerClient":
		initServer(s, &s.trWorkspaceLoggerServer, func() *WorkspaceLoggerServerTransport {
			return NewWorkspaceLoggerServerTransport(&s.srv.WorkspaceLoggerServer)
		})
		resp, err = s.trWorkspaceLoggerServer.Do(req)
	case "WorkspaceNamedValueClient":
		initServer(s, &s.trWorkspaceNamedValueServer, func() *WorkspaceNamedValueServerTransport {
			return NewWorkspaceNamedValueServerTransport(&s.srv.WorkspaceNamedValueServer)
		})
		resp, err = s.trWorkspaceNamedValueServer.Do(req)
	case "WorkspaceNotificationClient":
		initServer(s, &s.trWorkspaceNotificationServer, func() *WorkspaceNotificationServerTransport {
			return NewWorkspaceNotificationServerTransport(&s.srv.WorkspaceNotificationServer)
		})
		resp, err = s.trWorkspaceNotificationServer.Do(req)
	case "WorkspaceNotificationRecipientEmailClient":
		initServer(s, &s.trWorkspaceNotificationRecipientEmailServer, func() *WorkspaceNotificationRecipientEmailServerTransport {
			return NewWorkspaceNotificationRecipientEmailServerTransport(&s.srv.WorkspaceNotificationRecipientEmailServer)
		})
		resp, err = s.trWorkspaceNotificationRecipientEmailServer.Do(req)
	case "WorkspaceNotificationRecipientUserClient":
		initServer(s, &s.trWorkspaceNotificationRecipientUserServer, func() *WorkspaceNotificationRecipientUserServerTransport {
			return NewWorkspaceNotificationRecipientUserServerTransport(&s.srv.WorkspaceNotificationRecipientUserServer)
		})
		resp, err = s.trWorkspaceNotificationRecipientUserServer.Do(req)
	case "WorkspacePolicyClient":
		initServer(s, &s.trWorkspacePolicyServer, func() *WorkspacePolicyServerTransport {
			return NewWorkspacePolicyServerTransport(&s.srv.WorkspacePolicyServer)
		})
		resp, err = s.trWorkspacePolicyServer.Do(req)
	case "WorkspacePolicyFragmentClient":
		initServer(s, &s.trWorkspacePolicyFragmentServer, func() *WorkspacePolicyFragmentServerTransport {
			return NewWorkspacePolicyFragmentServerTransport(&s.srv.WorkspacePolicyFragmentServer)
		})
		resp, err = s.trWorkspacePolicyFragmentServer.Do(req)
	case "WorkspaceProductAPILinkClient":
		initServer(s, &s.trWorkspaceProductAPILinkServer, func() *WorkspaceProductAPILinkServerTransport {
			return NewWorkspaceProductAPILinkServerTransport(&s.srv.WorkspaceProductAPILinkServer)
		})
		resp, err = s.trWorkspaceProductAPILinkServer.Do(req)
	case "WorkspaceProductClient":
		initServer(s, &s.trWorkspaceProductServer, func() *WorkspaceProductServerTransport {
			return NewWorkspaceProductServerTransport(&s.srv.WorkspaceProductServer)
		})
		resp, err = s.trWorkspaceProductServer.Do(req)
	case "WorkspaceProductGroupLinkClient":
		initServer(s, &s.trWorkspaceProductGroupLinkServer, func() *WorkspaceProductGroupLinkServerTransport {
			return NewWorkspaceProductGroupLinkServerTransport(&s.srv.WorkspaceProductGroupLinkServer)
		})
		resp, err = s.trWorkspaceProductGroupLinkServer.Do(req)
	case "WorkspaceProductPolicyClient":
		initServer(s, &s.trWorkspaceProductPolicyServer, func() *WorkspaceProductPolicyServerTransport {
			return NewWorkspaceProductPolicyServerTransport(&s.srv.WorkspaceProductPolicyServer)
		})
		resp, err = s.trWorkspaceProductPolicyServer.Do(req)
	case "WorkspaceSubscriptionClient":
		initServer(s, &s.trWorkspaceSubscriptionServer, func() *WorkspaceSubscriptionServerTransport {
			return NewWorkspaceSubscriptionServerTransport(&s.srv.WorkspaceSubscriptionServer)
		})
		resp, err = s.trWorkspaceSubscriptionServer.Do(req)
	case "WorkspaceTagAPILinkClient":
		initServer(s, &s.trWorkspaceTagAPILinkServer, func() *WorkspaceTagAPILinkServerTransport {
			return NewWorkspaceTagAPILinkServerTransport(&s.srv.WorkspaceTagAPILinkServer)
		})
		resp, err = s.trWorkspaceTagAPILinkServer.Do(req)
	case "WorkspaceTagClient":
		initServer(s, &s.trWorkspaceTagServer, func() *WorkspaceTagServerTransport { return NewWorkspaceTagServerTransport(&s.srv.WorkspaceTagServer) })
		resp, err = s.trWorkspaceTagServer.Do(req)
	case "WorkspaceTagOperationLinkClient":
		initServer(s, &s.trWorkspaceTagOperationLinkServer, func() *WorkspaceTagOperationLinkServerTransport {
			return NewWorkspaceTagOperationLinkServerTransport(&s.srv.WorkspaceTagOperationLinkServer)
		})
		resp, err = s.trWorkspaceTagOperationLinkServer.Do(req)
	case "WorkspaceTagProductLinkClient":
		initServer(s, &s.trWorkspaceTagProductLinkServer, func() *WorkspaceTagProductLinkServerTransport {
			return NewWorkspaceTagProductLinkServerTransport(&s.srv.WorkspaceTagProductLinkServer)
		})
		resp, err = s.trWorkspaceTagProductLinkServer.Do(req)
	default:
		err = fmt.Errorf("unhandled client %s", client)
	}

	if err != nil {
		return nil, err
	}

	return resp, nil
}

func initServer[T any](s *ServerFactoryTransport, dst **T, src func() *T) {
	s.trMu.Lock()
	if *dst == nil {
		*dst = src()
	}
	s.trMu.Unlock()
}
