fake

package
v0.7.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 23, 2023 License: MIT Imports: 18 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AccountsServer 

type AccountsServer struct {
	// Get is the fake for method AccountsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, options *armbilling.AccountsClientGetOptions) (resp azfake.Responder[armbilling.AccountsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method AccountsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(options *armbilling.AccountsClientListOptions) (resp azfake.PagerResponder[armbilling.AccountsClientListResponse])

	// NewListInvoiceSectionsByCreateSubscriptionPermissionPager is the fake for method AccountsClient.NewListInvoiceSectionsByCreateSubscriptionPermissionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListInvoiceSectionsByCreateSubscriptionPermissionPager func(billingAccountName string, options *armbilling.AccountsClientListInvoiceSectionsByCreateSubscriptionPermissionOptions) (resp azfake.PagerResponder[armbilling.AccountsClientListInvoiceSectionsByCreateSubscriptionPermissionResponse])

	// BeginUpdate is the fake for method AccountsClient.BeginUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginUpdate func(ctx context.Context, billingAccountName string, parameters armbilling.AccountUpdateRequest, options *armbilling.AccountsClientBeginUpdateOptions) (resp azfake.PollerResponder[armbilling.AccountsClientUpdateResponse], errResp azfake.ErrorResponder)
}

AccountsServer is a fake server for instances of the armbilling.AccountsClient type.

type AccountsServerTransport 

type AccountsServerTransport struct {
	// contains filtered or unexported fields
}

AccountsServerTransport connects instances of armbilling.AccountsClient to instances of AccountsServer. Don't use this type directly, use NewAccountsServerTransport instead.

func NewAccountsServerTransport 

func NewAccountsServerTransport(srv *AccountsServer) *AccountsServerTransport

NewAccountsServerTransport creates a new instance of AccountsServerTransport with the provided implementation. The returned AccountsServerTransport instance is connected to an instance of armbilling.AccountsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*AccountsServerTransport) Do 

func (a *AccountsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for AccountsServerTransport.

type AddressServer 

type AddressServer struct {
	// Validate is the fake for method AddressClient.Validate
	// HTTP status codes to indicate success: http.StatusOK
	Validate func(ctx context.Context, address armbilling.AddressDetails, options *armbilling.AddressClientValidateOptions) (resp azfake.Responder[armbilling.AddressClientValidateResponse], errResp azfake.ErrorResponder)
}

AddressServer is a fake server for instances of the armbilling.AddressClient type.

type AddressServerTransport 

type AddressServerTransport struct {
	// contains filtered or unexported fields
}

AddressServerTransport connects instances of armbilling.AddressClient to instances of AddressServer. Don't use this type directly, use NewAddressServerTransport instead.

func NewAddressServerTransport 

func NewAddressServerTransport(srv *AddressServer) *AddressServerTransport

NewAddressServerTransport creates a new instance of AddressServerTransport with the provided implementation. The returned AddressServerTransport instance is connected to an instance of armbilling.AddressClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*AddressServerTransport) Do 

func (a *AddressServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for AddressServerTransport.

type AgreementsServer 

type AgreementsServer struct {
	// Get is the fake for method AgreementsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, agreementName string, options *armbilling.AgreementsClientGetOptions) (resp azfake.Responder[armbilling.AgreementsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByBillingAccountPager is the fake for method AgreementsClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, options *armbilling.AgreementsClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.AgreementsClientListByBillingAccountResponse])
}

AgreementsServer is a fake server for instances of the armbilling.AgreementsClient type.

type AgreementsServerTransport 

type AgreementsServerTransport struct {
	// contains filtered or unexported fields
}

AgreementsServerTransport connects instances of armbilling.AgreementsClient to instances of AgreementsServer. Don't use this type directly, use NewAgreementsServerTransport instead.

func NewAgreementsServerTransport 

func NewAgreementsServerTransport(srv *AgreementsServer) *AgreementsServerTransport

NewAgreementsServerTransport creates a new instance of AgreementsServerTransport with the provided implementation. The returned AgreementsServerTransport instance is connected to an instance of armbilling.AgreementsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*AgreementsServerTransport) Do 

func (a *AgreementsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for AgreementsServerTransport.

type AvailableBalancesServer 

type AvailableBalancesServer struct {
	// Get is the fake for method AvailableBalancesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, billingProfileName string, options *armbilling.AvailableBalancesClientGetOptions) (resp azfake.Responder[armbilling.AvailableBalancesClientGetResponse], errResp azfake.ErrorResponder)
}

AvailableBalancesServer is a fake server for instances of the armbilling.AvailableBalancesClient type.

type AvailableBalancesServerTransport 

type AvailableBalancesServerTransport struct {
	// contains filtered or unexported fields
}

AvailableBalancesServerTransport connects instances of armbilling.AvailableBalancesClient to instances of AvailableBalancesServer. Don't use this type directly, use NewAvailableBalancesServerTransport instead.

func NewAvailableBalancesServerTransport 

func NewAvailableBalancesServerTransport(srv *AvailableBalancesServer) *AvailableBalancesServerTransport

NewAvailableBalancesServerTransport creates a new instance of AvailableBalancesServerTransport with the provided implementation. The returned AvailableBalancesServerTransport instance is connected to an instance of armbilling.AvailableBalancesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*AvailableBalancesServerTransport) Do 

func (a *AvailableBalancesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for AvailableBalancesServerTransport.

type CustomersServer 

type CustomersServer struct {
	// Get is the fake for method CustomersClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, customerName string, options *armbilling.CustomersClientGetOptions) (resp azfake.Responder[armbilling.CustomersClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByBillingAccountPager is the fake for method CustomersClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, options *armbilling.CustomersClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.CustomersClientListByBillingAccountResponse])

	// NewListByBillingProfilePager is the fake for method CustomersClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, options *armbilling.CustomersClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.CustomersClientListByBillingProfileResponse])
}

CustomersServer is a fake server for instances of the armbilling.CustomersClient type.

type CustomersServerTransport 

type CustomersServerTransport struct {
	// contains filtered or unexported fields
}

CustomersServerTransport connects instances of armbilling.CustomersClient to instances of CustomersServer. Don't use this type directly, use NewCustomersServerTransport instead.

func NewCustomersServerTransport 

func NewCustomersServerTransport(srv *CustomersServer) *CustomersServerTransport

NewCustomersServerTransport creates a new instance of CustomersServerTransport with the provided implementation. The returned CustomersServerTransport instance is connected to an instance of armbilling.CustomersClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*CustomersServerTransport) Do 

func (c *CustomersServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for CustomersServerTransport.

type EnrollmentAccountsServer 

type EnrollmentAccountsServer struct {
	// Get is the fake for method EnrollmentAccountsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, name string, options *armbilling.EnrollmentAccountsClientGetOptions) (resp azfake.Responder[armbilling.EnrollmentAccountsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method EnrollmentAccountsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(options *armbilling.EnrollmentAccountsClientListOptions) (resp azfake.PagerResponder[armbilling.EnrollmentAccountsClientListResponse])
}

EnrollmentAccountsServer is a fake server for instances of the armbilling.EnrollmentAccountsClient type.

type EnrollmentAccountsServerTransport 

type EnrollmentAccountsServerTransport struct {
	// contains filtered or unexported fields
}

EnrollmentAccountsServerTransport connects instances of armbilling.EnrollmentAccountsClient to instances of EnrollmentAccountsServer. Don't use this type directly, use NewEnrollmentAccountsServerTransport instead.

func NewEnrollmentAccountsServerTransport 

func NewEnrollmentAccountsServerTransport(srv *EnrollmentAccountsServer) *EnrollmentAccountsServerTransport

NewEnrollmentAccountsServerTransport creates a new instance of EnrollmentAccountsServerTransport with the provided implementation. The returned EnrollmentAccountsServerTransport instance is connected to an instance of armbilling.EnrollmentAccountsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*EnrollmentAccountsServerTransport) Do 

func (e *EnrollmentAccountsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for EnrollmentAccountsServerTransport.

type InstructionsServer 

type InstructionsServer struct {
	// Get is the fake for method InstructionsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, billingProfileName string, instructionName string, options *armbilling.InstructionsClientGetOptions) (resp azfake.Responder[armbilling.InstructionsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByBillingProfilePager is the fake for method InstructionsClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, options *armbilling.InstructionsClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.InstructionsClientListByBillingProfileResponse])

	// Put is the fake for method InstructionsClient.Put
	// HTTP status codes to indicate success: http.StatusOK
	Put func(ctx context.Context, billingAccountName string, billingProfileName string, instructionName string, parameters armbilling.Instruction, options *armbilling.InstructionsClientPutOptions) (resp azfake.Responder[armbilling.InstructionsClientPutResponse], errResp azfake.ErrorResponder)
}

InstructionsServer is a fake server for instances of the armbilling.InstructionsClient type.

type InstructionsServerTransport 

type InstructionsServerTransport struct {
	// contains filtered or unexported fields
}

InstructionsServerTransport connects instances of armbilling.InstructionsClient to instances of InstructionsServer. Don't use this type directly, use NewInstructionsServerTransport instead.

func NewInstructionsServerTransport 

func NewInstructionsServerTransport(srv *InstructionsServer) *InstructionsServerTransport

NewInstructionsServerTransport creates a new instance of InstructionsServerTransport with the provided implementation. The returned InstructionsServerTransport instance is connected to an instance of armbilling.InstructionsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*InstructionsServerTransport) Do 

func (i *InstructionsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for InstructionsServerTransport.

type InvoiceSectionsServer 

type InvoiceSectionsServer struct {
	// BeginCreateOrUpdate is the fake for method InvoiceSectionsClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginCreateOrUpdate func(ctx context.Context, billingAccountName string, billingProfileName string, invoiceSectionName string, parameters armbilling.InvoiceSection, options *armbilling.InvoiceSectionsClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armbilling.InvoiceSectionsClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method InvoiceSectionsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, billingProfileName string, invoiceSectionName string, options *armbilling.InvoiceSectionsClientGetOptions) (resp azfake.Responder[armbilling.InvoiceSectionsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByBillingProfilePager is the fake for method InvoiceSectionsClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, options *armbilling.InvoiceSectionsClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.InvoiceSectionsClientListByBillingProfileResponse])
}

InvoiceSectionsServer is a fake server for instances of the armbilling.InvoiceSectionsClient type.

type InvoiceSectionsServerTransport 

type InvoiceSectionsServerTransport struct {
	// contains filtered or unexported fields
}

InvoiceSectionsServerTransport connects instances of armbilling.InvoiceSectionsClient to instances of InvoiceSectionsServer. Don't use this type directly, use NewInvoiceSectionsServerTransport instead.

func NewInvoiceSectionsServerTransport 

func NewInvoiceSectionsServerTransport(srv *InvoiceSectionsServer) *InvoiceSectionsServerTransport

NewInvoiceSectionsServerTransport creates a new instance of InvoiceSectionsServerTransport with the provided implementation. The returned InvoiceSectionsServerTransport instance is connected to an instance of armbilling.InvoiceSectionsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*InvoiceSectionsServerTransport) Do 

func (i *InvoiceSectionsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for InvoiceSectionsServerTransport.

type InvoicesServer 

type InvoicesServer struct {
	// BeginDownloadBillingSubscriptionInvoice is the fake for method InvoicesClient.BeginDownloadBillingSubscriptionInvoice
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginDownloadBillingSubscriptionInvoice func(ctx context.Context, invoiceName string, downloadToken string, options *armbilling.InvoicesClientBeginDownloadBillingSubscriptionInvoiceOptions) (resp azfake.PollerResponder[armbilling.InvoicesClientDownloadBillingSubscriptionInvoiceResponse], errResp azfake.ErrorResponder)

	// BeginDownloadInvoice is the fake for method InvoicesClient.BeginDownloadInvoice
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginDownloadInvoice func(ctx context.Context, billingAccountName string, invoiceName string, downloadToken string, options *armbilling.InvoicesClientBeginDownloadInvoiceOptions) (resp azfake.PollerResponder[armbilling.InvoicesClientDownloadInvoiceResponse], errResp azfake.ErrorResponder)

	// BeginDownloadMultipleBillingProfileInvoices is the fake for method InvoicesClient.BeginDownloadMultipleBillingProfileInvoices
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginDownloadMultipleBillingProfileInvoices func(ctx context.Context, billingAccountName string, downloadUrls []*string, options *armbilling.InvoicesClientBeginDownloadMultipleBillingProfileInvoicesOptions) (resp azfake.PollerResponder[armbilling.InvoicesClientDownloadMultipleBillingProfileInvoicesResponse], errResp azfake.ErrorResponder)

	// BeginDownloadMultipleBillingSubscriptionInvoices is the fake for method InvoicesClient.BeginDownloadMultipleBillingSubscriptionInvoices
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginDownloadMultipleBillingSubscriptionInvoices func(ctx context.Context, downloadUrls []*string, options *armbilling.InvoicesClientBeginDownloadMultipleBillingSubscriptionInvoicesOptions) (resp azfake.PollerResponder[armbilling.InvoicesClientDownloadMultipleBillingSubscriptionInvoicesResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method InvoicesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, invoiceName string, options *armbilling.InvoicesClientGetOptions) (resp azfake.Responder[armbilling.InvoicesClientGetResponse], errResp azfake.ErrorResponder)

	// GetByID is the fake for method InvoicesClient.GetByID
	// HTTP status codes to indicate success: http.StatusOK
	GetByID func(ctx context.Context, invoiceName string, options *armbilling.InvoicesClientGetByIDOptions) (resp azfake.Responder[armbilling.InvoicesClientGetByIDResponse], errResp azfake.ErrorResponder)

	// GetBySubscriptionAndInvoiceID is the fake for method InvoicesClient.GetBySubscriptionAndInvoiceID
	// HTTP status codes to indicate success: http.StatusOK
	GetBySubscriptionAndInvoiceID func(ctx context.Context, invoiceName string, options *armbilling.InvoicesClientGetBySubscriptionAndInvoiceIDOptions) (resp azfake.Responder[armbilling.InvoicesClientGetBySubscriptionAndInvoiceIDResponse], errResp azfake.ErrorResponder)

	// NewListByBillingAccountPager is the fake for method InvoicesClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, periodStartDate string, periodEndDate string, options *armbilling.InvoicesClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.InvoicesClientListByBillingAccountResponse])

	// NewListByBillingProfilePager is the fake for method InvoicesClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, periodStartDate string, periodEndDate string, options *armbilling.InvoicesClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.InvoicesClientListByBillingProfileResponse])

	// NewListByBillingSubscriptionPager is the fake for method InvoicesClient.NewListByBillingSubscriptionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingSubscriptionPager func(periodStartDate string, periodEndDate string, options *armbilling.InvoicesClientListByBillingSubscriptionOptions) (resp azfake.PagerResponder[armbilling.InvoicesClientListByBillingSubscriptionResponse])
}

InvoicesServer is a fake server for instances of the armbilling.InvoicesClient type.

type InvoicesServerTransport 

type InvoicesServerTransport struct {
	// contains filtered or unexported fields
}

InvoicesServerTransport connects instances of armbilling.InvoicesClient to instances of InvoicesServer. Don't use this type directly, use NewInvoicesServerTransport instead.

func NewInvoicesServerTransport 

func NewInvoicesServerTransport(srv *InvoicesServer) *InvoicesServerTransport

NewInvoicesServerTransport creates a new instance of InvoicesServerTransport with the provided implementation. The returned InvoicesServerTransport instance is connected to an instance of armbilling.InvoicesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*InvoicesServerTransport) Do 

func (i *InvoicesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for InvoicesServerTransport.

type OperationsServer 

type OperationsServer struct {
	// NewListPager is the fake for method OperationsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(options *armbilling.OperationsClientListOptions) (resp azfake.PagerResponder[armbilling.OperationsClientListResponse])
}

OperationsServer is a fake server for instances of the armbilling.OperationsClient type.

type OperationsServerTransport 

type OperationsServerTransport struct {
	// contains filtered or unexported fields
}

OperationsServerTransport connects instances of armbilling.OperationsClient to instances of OperationsServer. Don't use this type directly, use NewOperationsServerTransport instead.

func NewOperationsServerTransport 

func NewOperationsServerTransport(srv *OperationsServer) *OperationsServerTransport

NewOperationsServerTransport creates a new instance of OperationsServerTransport with the provided implementation. The returned OperationsServerTransport instance is connected to an instance of armbilling.OperationsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*OperationsServerTransport) Do 

func (o *OperationsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for OperationsServerTransport.

type PeriodsServer 

type PeriodsServer struct {
	// Get is the fake for method PeriodsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingPeriodName string, options *armbilling.PeriodsClientGetOptions) (resp azfake.Responder[armbilling.PeriodsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListPager is the fake for method PeriodsClient.NewListPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListPager func(options *armbilling.PeriodsClientListOptions) (resp azfake.PagerResponder[armbilling.PeriodsClientListResponse])
}

PeriodsServer is a fake server for instances of the armbilling.PeriodsClient type.

type PeriodsServerTransport 

type PeriodsServerTransport struct {
	// contains filtered or unexported fields
}

PeriodsServerTransport connects instances of armbilling.PeriodsClient to instances of PeriodsServer. Don't use this type directly, use NewPeriodsServerTransport instead.

func NewPeriodsServerTransport 

func NewPeriodsServerTransport(srv *PeriodsServer) *PeriodsServerTransport

NewPeriodsServerTransport creates a new instance of PeriodsServerTransport with the provided implementation. The returned PeriodsServerTransport instance is connected to an instance of armbilling.PeriodsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*PeriodsServerTransport) Do 

func (p *PeriodsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for PeriodsServerTransport.

type PermissionsServer 

type PermissionsServer struct {
	// NewListByBillingAccountPager is the fake for method PermissionsClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, options *armbilling.PermissionsClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.PermissionsClientListByBillingAccountResponse])

	// NewListByBillingProfilePager is the fake for method PermissionsClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, options *armbilling.PermissionsClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.PermissionsClientListByBillingProfileResponse])

	// NewListByCustomerPager is the fake for method PermissionsClient.NewListByCustomerPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByCustomerPager func(billingAccountName string, customerName string, options *armbilling.PermissionsClientListByCustomerOptions) (resp azfake.PagerResponder[armbilling.PermissionsClientListByCustomerResponse])

	// NewListByInvoiceSectionsPager is the fake for method PermissionsClient.NewListByInvoiceSectionsPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByInvoiceSectionsPager func(billingAccountName string, billingProfileName string, invoiceSectionName string, options *armbilling.PermissionsClientListByInvoiceSectionsOptions) (resp azfake.PagerResponder[armbilling.PermissionsClientListByInvoiceSectionsResponse])
}

PermissionsServer is a fake server for instances of the armbilling.PermissionsClient type.

type PermissionsServerTransport 

type PermissionsServerTransport struct {
	// contains filtered or unexported fields
}

PermissionsServerTransport connects instances of armbilling.PermissionsClient to instances of PermissionsServer. Don't use this type directly, use NewPermissionsServerTransport instead.

func NewPermissionsServerTransport 

func NewPermissionsServerTransport(srv *PermissionsServer) *PermissionsServerTransport

NewPermissionsServerTransport creates a new instance of PermissionsServerTransport with the provided implementation. The returned PermissionsServerTransport instance is connected to an instance of armbilling.PermissionsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*PermissionsServerTransport) Do 

func (p *PermissionsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for PermissionsServerTransport.

type PoliciesServer 

type PoliciesServer struct {
	// GetByBillingProfile is the fake for method PoliciesClient.GetByBillingProfile
	// HTTP status codes to indicate success: http.StatusOK
	GetByBillingProfile func(ctx context.Context, billingAccountName string, billingProfileName string, options *armbilling.PoliciesClientGetByBillingProfileOptions) (resp azfake.Responder[armbilling.PoliciesClientGetByBillingProfileResponse], errResp azfake.ErrorResponder)

	// GetByCustomer is the fake for method PoliciesClient.GetByCustomer
	// HTTP status codes to indicate success: http.StatusOK
	GetByCustomer func(ctx context.Context, billingAccountName string, customerName string, options *armbilling.PoliciesClientGetByCustomerOptions) (resp azfake.Responder[armbilling.PoliciesClientGetByCustomerResponse], errResp azfake.ErrorResponder)

	// Update is the fake for method PoliciesClient.Update
	// HTTP status codes to indicate success: http.StatusOK
	Update func(ctx context.Context, billingAccountName string, billingProfileName string, parameters armbilling.Policy, options *armbilling.PoliciesClientUpdateOptions) (resp azfake.Responder[armbilling.PoliciesClientUpdateResponse], errResp azfake.ErrorResponder)

	// UpdateCustomer is the fake for method PoliciesClient.UpdateCustomer
	// HTTP status codes to indicate success: http.StatusOK
	UpdateCustomer func(ctx context.Context, billingAccountName string, customerName string, parameters armbilling.CustomerPolicy, options *armbilling.PoliciesClientUpdateCustomerOptions) (resp azfake.Responder[armbilling.PoliciesClientUpdateCustomerResponse], errResp azfake.ErrorResponder)
}

PoliciesServer is a fake server for instances of the armbilling.PoliciesClient type.

type PoliciesServerTransport 

type PoliciesServerTransport struct {
	// contains filtered or unexported fields
}

PoliciesServerTransport connects instances of armbilling.PoliciesClient to instances of PoliciesServer. Don't use this type directly, use NewPoliciesServerTransport instead.

func NewPoliciesServerTransport 

func NewPoliciesServerTransport(srv *PoliciesServer) *PoliciesServerTransport

NewPoliciesServerTransport creates a new instance of PoliciesServerTransport with the provided implementation. The returned PoliciesServerTransport instance is connected to an instance of armbilling.PoliciesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*PoliciesServerTransport) Do 

func (p *PoliciesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for PoliciesServerTransport.

type ProductsServer 

type ProductsServer struct {
	// Get is the fake for method ProductsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, productName string, options *armbilling.ProductsClientGetOptions) (resp azfake.Responder[armbilling.ProductsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByBillingAccountPager is the fake for method ProductsClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, options *armbilling.ProductsClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.ProductsClientListByBillingAccountResponse])

	// NewListByBillingProfilePager is the fake for method ProductsClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, options *armbilling.ProductsClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.ProductsClientListByBillingProfileResponse])

	// NewListByCustomerPager is the fake for method ProductsClient.NewListByCustomerPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByCustomerPager func(billingAccountName string, customerName string, options *armbilling.ProductsClientListByCustomerOptions) (resp azfake.PagerResponder[armbilling.ProductsClientListByCustomerResponse])

	// NewListByInvoiceSectionPager is the fake for method ProductsClient.NewListByInvoiceSectionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByInvoiceSectionPager func(billingAccountName string, billingProfileName string, invoiceSectionName string, options *armbilling.ProductsClientListByInvoiceSectionOptions) (resp azfake.PagerResponder[armbilling.ProductsClientListByInvoiceSectionResponse])

	// Move is the fake for method ProductsClient.Move
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	Move func(ctx context.Context, billingAccountName string, productName string, parameters armbilling.TransferProductRequestProperties, options *armbilling.ProductsClientMoveOptions) (resp azfake.Responder[armbilling.ProductsClientMoveResponse], errResp azfake.ErrorResponder)

	// Update is the fake for method ProductsClient.Update
	// HTTP status codes to indicate success: http.StatusOK
	Update func(ctx context.Context, billingAccountName string, productName string, parameters armbilling.Product, options *armbilling.ProductsClientUpdateOptions) (resp azfake.Responder[armbilling.ProductsClientUpdateResponse], errResp azfake.ErrorResponder)

	// ValidateMove is the fake for method ProductsClient.ValidateMove
	// HTTP status codes to indicate success: http.StatusOK
	ValidateMove func(ctx context.Context, billingAccountName string, productName string, parameters armbilling.TransferProductRequestProperties, options *armbilling.ProductsClientValidateMoveOptions) (resp azfake.Responder[armbilling.ProductsClientValidateMoveResponse], errResp azfake.ErrorResponder)
}

ProductsServer is a fake server for instances of the armbilling.ProductsClient type.

type ProductsServerTransport 

type ProductsServerTransport struct {
	// contains filtered or unexported fields
}

ProductsServerTransport connects instances of armbilling.ProductsClient to instances of ProductsServer. Don't use this type directly, use NewProductsServerTransport instead.

func NewProductsServerTransport 

func NewProductsServerTransport(srv *ProductsServer) *ProductsServerTransport

NewProductsServerTransport creates a new instance of ProductsServerTransport with the provided implementation. The returned ProductsServerTransport instance is connected to an instance of armbilling.ProductsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ProductsServerTransport) Do 

func (p *ProductsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ProductsServerTransport.

type ProfilesServer 

type ProfilesServer struct {
	// BeginCreateOrUpdate is the fake for method ProfilesClient.BeginCreateOrUpdate
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginCreateOrUpdate func(ctx context.Context, billingAccountName string, billingProfileName string, parameters armbilling.Profile, options *armbilling.ProfilesClientBeginCreateOrUpdateOptions) (resp azfake.PollerResponder[armbilling.ProfilesClientCreateOrUpdateResponse], errResp azfake.ErrorResponder)

	// Get is the fake for method ProfilesClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, billingProfileName string, options *armbilling.ProfilesClientGetOptions) (resp azfake.Responder[armbilling.ProfilesClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByBillingAccountPager is the fake for method ProfilesClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, options *armbilling.ProfilesClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.ProfilesClientListByBillingAccountResponse])
}

ProfilesServer is a fake server for instances of the armbilling.ProfilesClient type.

type ProfilesServerTransport 

type ProfilesServerTransport struct {
	// contains filtered or unexported fields
}

ProfilesServerTransport connects instances of armbilling.ProfilesClient to instances of ProfilesServer. Don't use this type directly, use NewProfilesServerTransport instead.

func NewProfilesServerTransport 

func NewProfilesServerTransport(srv *ProfilesServer) *ProfilesServerTransport

NewProfilesServerTransport creates a new instance of ProfilesServerTransport with the provided implementation. The returned ProfilesServerTransport instance is connected to an instance of armbilling.ProfilesClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ProfilesServerTransport) Do 

func (p *ProfilesServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ProfilesServerTransport.

type PropertyServer 

type PropertyServer struct {
	// Get is the fake for method PropertyClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, options *armbilling.PropertyClientGetOptions) (resp azfake.Responder[armbilling.PropertyClientGetResponse], errResp azfake.ErrorResponder)

	// Update is the fake for method PropertyClient.Update
	// HTTP status codes to indicate success: http.StatusOK
	Update func(ctx context.Context, parameters armbilling.Property, options *armbilling.PropertyClientUpdateOptions) (resp azfake.Responder[armbilling.PropertyClientUpdateResponse], errResp azfake.ErrorResponder)
}

PropertyServer is a fake server for instances of the armbilling.PropertyClient type.

type PropertyServerTransport 

type PropertyServerTransport struct {
	// contains filtered or unexported fields
}

PropertyServerTransport connects instances of armbilling.PropertyClient to instances of PropertyServer. Don't use this type directly, use NewPropertyServerTransport instead.

func NewPropertyServerTransport 

func NewPropertyServerTransport(srv *PropertyServer) *PropertyServerTransport

NewPropertyServerTransport creates a new instance of PropertyServerTransport with the provided implementation. The returned PropertyServerTransport instance is connected to an instance of armbilling.PropertyClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*PropertyServerTransport) Do 

func (p *PropertyServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for PropertyServerTransport.

type ReservationsServer 

type ReservationsServer struct {
	// NewListByBillingAccountPager is the fake for method ReservationsClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, options *armbilling.ReservationsClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.ReservationsClientListByBillingAccountResponse])

	// NewListByBillingProfilePager is the fake for method ReservationsClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, options *armbilling.ReservationsClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.ReservationsClientListByBillingProfileResponse])
}

ReservationsServer is a fake server for instances of the armbilling.ReservationsClient type.

type ReservationsServerTransport 

type ReservationsServerTransport struct {
	// contains filtered or unexported fields
}

ReservationsServerTransport connects instances of armbilling.ReservationsClient to instances of ReservationsServer. Don't use this type directly, use NewReservationsServerTransport instead.

func NewReservationsServerTransport 

func NewReservationsServerTransport(srv *ReservationsServer) *ReservationsServerTransport

NewReservationsServerTransport creates a new instance of ReservationsServerTransport with the provided implementation. The returned ReservationsServerTransport instance is connected to an instance of armbilling.ReservationsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ReservationsServerTransport) Do 

func (r *ReservationsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ReservationsServerTransport.

type RoleAssignmentsServer 

type RoleAssignmentsServer struct {
	// DeleteByBillingAccount is the fake for method RoleAssignmentsClient.DeleteByBillingAccount
	// HTTP status codes to indicate success: http.StatusOK
	DeleteByBillingAccount func(ctx context.Context, billingAccountName string, billingRoleAssignmentName string, options *armbilling.RoleAssignmentsClientDeleteByBillingAccountOptions) (resp azfake.Responder[armbilling.RoleAssignmentsClientDeleteByBillingAccountResponse], errResp azfake.ErrorResponder)

	// DeleteByBillingProfile is the fake for method RoleAssignmentsClient.DeleteByBillingProfile
	// HTTP status codes to indicate success: http.StatusOK
	DeleteByBillingProfile func(ctx context.Context, billingAccountName string, billingProfileName string, billingRoleAssignmentName string, options *armbilling.RoleAssignmentsClientDeleteByBillingProfileOptions) (resp azfake.Responder[armbilling.RoleAssignmentsClientDeleteByBillingProfileResponse], errResp azfake.ErrorResponder)

	// DeleteByInvoiceSection is the fake for method RoleAssignmentsClient.DeleteByInvoiceSection
	// HTTP status codes to indicate success: http.StatusOK
	DeleteByInvoiceSection func(ctx context.Context, billingAccountName string, billingProfileName string, invoiceSectionName string, billingRoleAssignmentName string, options *armbilling.RoleAssignmentsClientDeleteByInvoiceSectionOptions) (resp azfake.Responder[armbilling.RoleAssignmentsClientDeleteByInvoiceSectionResponse], errResp azfake.ErrorResponder)

	// GetByBillingAccount is the fake for method RoleAssignmentsClient.GetByBillingAccount
	// HTTP status codes to indicate success: http.StatusOK
	GetByBillingAccount func(ctx context.Context, billingAccountName string, billingRoleAssignmentName string, options *armbilling.RoleAssignmentsClientGetByBillingAccountOptions) (resp azfake.Responder[armbilling.RoleAssignmentsClientGetByBillingAccountResponse], errResp azfake.ErrorResponder)

	// GetByBillingProfile is the fake for method RoleAssignmentsClient.GetByBillingProfile
	// HTTP status codes to indicate success: http.StatusOK
	GetByBillingProfile func(ctx context.Context, billingAccountName string, billingProfileName string, billingRoleAssignmentName string, options *armbilling.RoleAssignmentsClientGetByBillingProfileOptions) (resp azfake.Responder[armbilling.RoleAssignmentsClientGetByBillingProfileResponse], errResp azfake.ErrorResponder)

	// GetByInvoiceSection is the fake for method RoleAssignmentsClient.GetByInvoiceSection
	// HTTP status codes to indicate success: http.StatusOK
	GetByInvoiceSection func(ctx context.Context, billingAccountName string, billingProfileName string, invoiceSectionName string, billingRoleAssignmentName string, options *armbilling.RoleAssignmentsClientGetByInvoiceSectionOptions) (resp azfake.Responder[armbilling.RoleAssignmentsClientGetByInvoiceSectionResponse], errResp azfake.ErrorResponder)

	// NewListByBillingAccountPager is the fake for method RoleAssignmentsClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, options *armbilling.RoleAssignmentsClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.RoleAssignmentsClientListByBillingAccountResponse])

	// NewListByBillingProfilePager is the fake for method RoleAssignmentsClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, options *armbilling.RoleAssignmentsClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.RoleAssignmentsClientListByBillingProfileResponse])

	// NewListByInvoiceSectionPager is the fake for method RoleAssignmentsClient.NewListByInvoiceSectionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByInvoiceSectionPager func(billingAccountName string, billingProfileName string, invoiceSectionName string, options *armbilling.RoleAssignmentsClientListByInvoiceSectionOptions) (resp azfake.PagerResponder[armbilling.RoleAssignmentsClientListByInvoiceSectionResponse])
}

RoleAssignmentsServer is a fake server for instances of the armbilling.RoleAssignmentsClient type.

type RoleAssignmentsServerTransport 

type RoleAssignmentsServerTransport struct {
	// contains filtered or unexported fields
}

RoleAssignmentsServerTransport connects instances of armbilling.RoleAssignmentsClient to instances of RoleAssignmentsServer. Don't use this type directly, use NewRoleAssignmentsServerTransport instead.

func NewRoleAssignmentsServerTransport 

func NewRoleAssignmentsServerTransport(srv *RoleAssignmentsServer) *RoleAssignmentsServerTransport

NewRoleAssignmentsServerTransport creates a new instance of RoleAssignmentsServerTransport with the provided implementation. The returned RoleAssignmentsServerTransport instance is connected to an instance of armbilling.RoleAssignmentsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*RoleAssignmentsServerTransport) Do 

func (r *RoleAssignmentsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for RoleAssignmentsServerTransport.

type RoleDefinitionsServer 

type RoleDefinitionsServer struct {
	// GetByBillingAccount is the fake for method RoleDefinitionsClient.GetByBillingAccount
	// HTTP status codes to indicate success: http.StatusOK
	GetByBillingAccount func(ctx context.Context, billingAccountName string, billingRoleDefinitionName string, options *armbilling.RoleDefinitionsClientGetByBillingAccountOptions) (resp azfake.Responder[armbilling.RoleDefinitionsClientGetByBillingAccountResponse], errResp azfake.ErrorResponder)

	// GetByBillingProfile is the fake for method RoleDefinitionsClient.GetByBillingProfile
	// HTTP status codes to indicate success: http.StatusOK
	GetByBillingProfile func(ctx context.Context, billingAccountName string, billingProfileName string, billingRoleDefinitionName string, options *armbilling.RoleDefinitionsClientGetByBillingProfileOptions) (resp azfake.Responder[armbilling.RoleDefinitionsClientGetByBillingProfileResponse], errResp azfake.ErrorResponder)

	// GetByInvoiceSection is the fake for method RoleDefinitionsClient.GetByInvoiceSection
	// HTTP status codes to indicate success: http.StatusOK
	GetByInvoiceSection func(ctx context.Context, billingAccountName string, billingProfileName string, invoiceSectionName string, billingRoleDefinitionName string, options *armbilling.RoleDefinitionsClientGetByInvoiceSectionOptions) (resp azfake.Responder[armbilling.RoleDefinitionsClientGetByInvoiceSectionResponse], errResp azfake.ErrorResponder)

	// NewListByBillingAccountPager is the fake for method RoleDefinitionsClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, options *armbilling.RoleDefinitionsClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.RoleDefinitionsClientListByBillingAccountResponse])

	// NewListByBillingProfilePager is the fake for method RoleDefinitionsClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, options *armbilling.RoleDefinitionsClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.RoleDefinitionsClientListByBillingProfileResponse])

	// NewListByInvoiceSectionPager is the fake for method RoleDefinitionsClient.NewListByInvoiceSectionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByInvoiceSectionPager func(billingAccountName string, billingProfileName string, invoiceSectionName string, options *armbilling.RoleDefinitionsClientListByInvoiceSectionOptions) (resp azfake.PagerResponder[armbilling.RoleDefinitionsClientListByInvoiceSectionResponse])
}

RoleDefinitionsServer is a fake server for instances of the armbilling.RoleDefinitionsClient type.

type RoleDefinitionsServerTransport 

type RoleDefinitionsServerTransport struct {
	// contains filtered or unexported fields
}

RoleDefinitionsServerTransport connects instances of armbilling.RoleDefinitionsClient to instances of RoleDefinitionsServer. Don't use this type directly, use NewRoleDefinitionsServerTransport instead.

func NewRoleDefinitionsServerTransport 

func NewRoleDefinitionsServerTransport(srv *RoleDefinitionsServer) *RoleDefinitionsServerTransport

NewRoleDefinitionsServerTransport creates a new instance of RoleDefinitionsServerTransport with the provided implementation. The returned RoleDefinitionsServerTransport instance is connected to an instance of armbilling.RoleDefinitionsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*RoleDefinitionsServerTransport) Do 

func (r *RoleDefinitionsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for RoleDefinitionsServerTransport.

type ServerFactory 

type ServerFactory struct {
	AccountsServer           AccountsServer
	AddressServer            AddressServer
	AgreementsServer         AgreementsServer
	AvailableBalancesServer  AvailableBalancesServer
	CustomersServer          CustomersServer
	EnrollmentAccountsServer EnrollmentAccountsServer
	InstructionsServer       InstructionsServer
	InvoiceSectionsServer    InvoiceSectionsServer
	InvoicesServer           InvoicesServer
	OperationsServer         OperationsServer
	PeriodsServer            PeriodsServer
	PermissionsServer        PermissionsServer
	PoliciesServer           PoliciesServer
	ProductsServer           ProductsServer
	ProfilesServer           ProfilesServer
	PropertyServer           PropertyServer
	ReservationsServer       ReservationsServer
	RoleAssignmentsServer    RoleAssignmentsServer
	RoleDefinitionsServer    RoleDefinitionsServer
	SubscriptionsServer      SubscriptionsServer
	TransactionsServer       TransactionsServer
}

ServerFactory is a fake server for instances of the armbilling.ClientFactory type.

type ServerFactoryTransport 

type ServerFactoryTransport struct {
	// contains filtered or unexported fields
}

ServerFactoryTransport connects instances of armbilling.ClientFactory to instances of ServerFactory. Don't use this type directly, use NewServerFactoryTransport instead.

func NewServerFactoryTransport 

func NewServerFactoryTransport(srv *ServerFactory) *ServerFactoryTransport

NewServerFactoryTransport creates a new instance of ServerFactoryTransport with the provided implementation. The returned ServerFactoryTransport instance is connected to an instance of armbilling.ClientFactory via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*ServerFactoryTransport) Do 

func (s *ServerFactoryTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for ServerFactoryTransport.

type SubscriptionsServer 

type SubscriptionsServer struct {
	// Get is the fake for method SubscriptionsClient.Get
	// HTTP status codes to indicate success: http.StatusOK
	Get func(ctx context.Context, billingAccountName string, options *armbilling.SubscriptionsClientGetOptions) (resp azfake.Responder[armbilling.SubscriptionsClientGetResponse], errResp azfake.ErrorResponder)

	// NewListByBillingAccountPager is the fake for method SubscriptionsClient.NewListByBillingAccountPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingAccountPager func(billingAccountName string, options *armbilling.SubscriptionsClientListByBillingAccountOptions) (resp azfake.PagerResponder[armbilling.SubscriptionsClientListByBillingAccountResponse])

	// NewListByBillingProfilePager is the fake for method SubscriptionsClient.NewListByBillingProfilePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByBillingProfilePager func(billingAccountName string, billingProfileName string, options *armbilling.SubscriptionsClientListByBillingProfileOptions) (resp azfake.PagerResponder[armbilling.SubscriptionsClientListByBillingProfileResponse])

	// NewListByCustomerPager is the fake for method SubscriptionsClient.NewListByCustomerPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByCustomerPager func(billingAccountName string, customerName string, options *armbilling.SubscriptionsClientListByCustomerOptions) (resp azfake.PagerResponder[armbilling.SubscriptionsClientListByCustomerResponse])

	// NewListByInvoiceSectionPager is the fake for method SubscriptionsClient.NewListByInvoiceSectionPager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByInvoiceSectionPager func(billingAccountName string, billingProfileName string, invoiceSectionName string, options *armbilling.SubscriptionsClientListByInvoiceSectionOptions) (resp azfake.PagerResponder[armbilling.SubscriptionsClientListByInvoiceSectionResponse])

	// BeginMove is the fake for method SubscriptionsClient.BeginMove
	// HTTP status codes to indicate success: http.StatusOK, http.StatusAccepted
	BeginMove func(ctx context.Context, billingAccountName string, parameters armbilling.TransferBillingSubscriptionRequestProperties, options *armbilling.SubscriptionsClientBeginMoveOptions) (resp azfake.PollerResponder[armbilling.SubscriptionsClientMoveResponse], errResp azfake.ErrorResponder)

	// Update is the fake for method SubscriptionsClient.Update
	// HTTP status codes to indicate success: http.StatusOK
	Update func(ctx context.Context, billingAccountName string, parameters armbilling.Subscription, options *armbilling.SubscriptionsClientUpdateOptions) (resp azfake.Responder[armbilling.SubscriptionsClientUpdateResponse], errResp azfake.ErrorResponder)

	// ValidateMove is the fake for method SubscriptionsClient.ValidateMove
	// HTTP status codes to indicate success: http.StatusOK
	ValidateMove func(ctx context.Context, billingAccountName string, parameters armbilling.TransferBillingSubscriptionRequestProperties, options *armbilling.SubscriptionsClientValidateMoveOptions) (resp azfake.Responder[armbilling.SubscriptionsClientValidateMoveResponse], errResp azfake.ErrorResponder)
}

SubscriptionsServer is a fake server for instances of the armbilling.SubscriptionsClient type.

type SubscriptionsServerTransport 

type SubscriptionsServerTransport struct {
	// contains filtered or unexported fields
}

SubscriptionsServerTransport connects instances of armbilling.SubscriptionsClient to instances of SubscriptionsServer. Don't use this type directly, use NewSubscriptionsServerTransport instead.

func NewSubscriptionsServerTransport 

func NewSubscriptionsServerTransport(srv *SubscriptionsServer) *SubscriptionsServerTransport

NewSubscriptionsServerTransport creates a new instance of SubscriptionsServerTransport with the provided implementation. The returned SubscriptionsServerTransport instance is connected to an instance of armbilling.SubscriptionsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*SubscriptionsServerTransport) Do 

func (s *SubscriptionsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for SubscriptionsServerTransport.

type TransactionsServer 

type TransactionsServer struct {
	// NewListByInvoicePager is the fake for method TransactionsClient.NewListByInvoicePager
	// HTTP status codes to indicate success: http.StatusOK
	NewListByInvoicePager func(billingAccountName string, invoiceName string, options *armbilling.TransactionsClientListByInvoiceOptions) (resp azfake.PagerResponder[armbilling.TransactionsClientListByInvoiceResponse])
}

TransactionsServer is a fake server for instances of the armbilling.TransactionsClient type.

type TransactionsServerTransport 

type TransactionsServerTransport struct {
	// contains filtered or unexported fields
}

TransactionsServerTransport connects instances of armbilling.TransactionsClient to instances of TransactionsServer. Don't use this type directly, use NewTransactionsServerTransport instead.

func NewTransactionsServerTransport 

func NewTransactionsServerTransport(srv *TransactionsServer) *TransactionsServerTransport

NewTransactionsServerTransport creates a new instance of TransactionsServerTransport with the provided implementation. The returned TransactionsServerTransport instance is connected to an instance of armbilling.TransactionsClient via the azcore.ClientOptions.Transporter field in the client's constructor parameters.

func (*TransactionsServerTransport) Do 

func (t *TransactionsServerTransport) Do(req *http.Request) (*http.Response, error)

Do implements the policy.Transporter interface for TransactionsServerTransport.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.