remnawave-api-go/api/client_ext.go

// Code generated by pipeline.py. DO NOT EDIT manually.

package api

import "context"

// ClientExt wraps the base Client with organized sub-client access.
// Use controller methods (e.g., client.Users().GetByUuid()) to call API operations.
type ClientExt struct {
	client *Client
	apiTokens *ApiTokensClient
	auth *AuthClient
	bandwidthStatsNodes *BandwidthStatsNodesClient
	bandwidthStatsUsers *BandwidthStatsUsersClient
	configProfile *ConfigProfileClient
	externalSquad *ExternalSquadClient
	hosts *HostsClient
	hostsBulkActions *HostsBulkActionsClient
	hwidUserDevices *HwidUserDevicesClient
	infraBilling *InfraBillingClient
	internalSquad *InternalSquadClient
	ipControl *IpControlClient
	keygen *KeygenClient
	metadata *MetadataClient
	nodePlugin *NodePluginClient
	nodes *NodesClient
	nodesUsageHistory *NodesUsageHistoryClient
	passkey *PasskeyClient
	remnawaveSettings *RemnawaveSettingsClient
	snippets *SnippetsClient
	subscription *SubscriptionClient
	subscriptionPageConfig *SubscriptionPageConfigClient
	subscriptionSettings *SubscriptionSettingsClient
	subscriptionTemplate *SubscriptionTemplateClient
	subscriptions *SubscriptionsClient
	system *SystemClient
	torrentBlockerReports *TorrentBlockerReportsClient
	userSubscriptionRequestHistory *UserSubscriptionRequestHistoryClient
	users *UsersClient
	usersBulkActions *UsersBulkActionsClient
}

// NewClientExt creates a new ClientExt wrapper.
func NewClientExt(client *Client) *ClientExt {
	return &ClientExt{
		client: client,
		apiTokens: NewApiTokensClient(client),
		auth: NewAuthClient(client),
		bandwidthStatsNodes: NewBandwidthStatsNodesClient(client),
		bandwidthStatsUsers: NewBandwidthStatsUsersClient(client),
		configProfile: NewConfigProfileClient(client),
		externalSquad: NewExternalSquadClient(client),
		hosts: NewHostsClient(client),
		hostsBulkActions: NewHostsBulkActionsClient(client),
		hwidUserDevices: NewHwidUserDevicesClient(client),
		infraBilling: NewInfraBillingClient(client),
		internalSquad: NewInternalSquadClient(client),
		ipControl: NewIpControlClient(client),
		keygen: NewKeygenClient(client),
		metadata: NewMetadataClient(client),
		nodePlugin: NewNodePluginClient(client),
		nodes: NewNodesClient(client),
		nodesUsageHistory: NewNodesUsageHistoryClient(client),
		passkey: NewPasskeyClient(client),
		remnawaveSettings: NewRemnawaveSettingsClient(client),
		snippets: NewSnippetsClient(client),
		subscription: NewSubscriptionClient(client),
		subscriptionPageConfig: NewSubscriptionPageConfigClient(client),
		subscriptionSettings: NewSubscriptionSettingsClient(client),
		subscriptionTemplate: NewSubscriptionTemplateClient(client),
		subscriptions: NewSubscriptionsClient(client),
		system: NewSystemClient(client),
		torrentBlockerReports: NewTorrentBlockerReportsClient(client),
		userSubscriptionRequestHistory: NewUserSubscriptionRequestHistoryClient(client),
		users: NewUsersClient(client),
		usersBulkActions: NewUsersBulkActionsClient(client),
	}
}

// Client returns the underlying ogen Client.
func (ce *ClientExt) Client() *Client {
	return ce.client
}

// ApiTokens returns the ApiTokensClient.
func (ce *ClientExt) ApiTokens() *ApiTokensClient {
	return ce.apiTokens
}

// Auth returns the AuthClient.
func (ce *ClientExt) Auth() *AuthClient {
	return ce.auth
}

// BandwidthStatsNodes returns the BandwidthStatsNodesClient.
func (ce *ClientExt) BandwidthStatsNodes() *BandwidthStatsNodesClient {
	return ce.bandwidthStatsNodes
}

// BandwidthStatsUsers returns the BandwidthStatsUsersClient.
func (ce *ClientExt) BandwidthStatsUsers() *BandwidthStatsUsersClient {
	return ce.bandwidthStatsUsers
}

// ConfigProfile returns the ConfigProfileClient.
func (ce *ClientExt) ConfigProfile() *ConfigProfileClient {
	return ce.configProfile
}

// ExternalSquad returns the ExternalSquadClient.
func (ce *ClientExt) ExternalSquad() *ExternalSquadClient {
	return ce.externalSquad
}

// Hosts returns the HostsClient.
func (ce *ClientExt) Hosts() *HostsClient {
	return ce.hosts
}

// HostsBulkActions returns the HostsBulkActionsClient.
func (ce *ClientExt) HostsBulkActions() *HostsBulkActionsClient {
	return ce.hostsBulkActions
}

// HwidUserDevices returns the HwidUserDevicesClient.
func (ce *ClientExt) HwidUserDevices() *HwidUserDevicesClient {
	return ce.hwidUserDevices
}

// InfraBilling returns the InfraBillingClient.
func (ce *ClientExt) InfraBilling() *InfraBillingClient {
	return ce.infraBilling
}

// InternalSquad returns the InternalSquadClient.
func (ce *ClientExt) InternalSquad() *InternalSquadClient {
	return ce.internalSquad
}

// IpControl returns the IpControlClient.
func (ce *ClientExt) IpControl() *IpControlClient {
	return ce.ipControl
}

// Keygen returns the KeygenClient.
func (ce *ClientExt) Keygen() *KeygenClient {
	return ce.keygen
}

// Metadata returns the MetadataClient.
func (ce *ClientExt) Metadata() *MetadataClient {
	return ce.metadata
}

// NodePlugin returns the NodePluginClient.
func (ce *ClientExt) NodePlugin() *NodePluginClient {
	return ce.nodePlugin
}

// Nodes returns the NodesClient.
func (ce *ClientExt) Nodes() *NodesClient {
	return ce.nodes
}

// NodesUsageHistory returns the NodesUsageHistoryClient.
func (ce *ClientExt) NodesUsageHistory() *NodesUsageHistoryClient {
	return ce.nodesUsageHistory
}

// Passkey returns the PasskeyClient.
func (ce *ClientExt) Passkey() *PasskeyClient {
	return ce.passkey
}

// RemnawaveSettings returns the RemnawaveSettingsClient.
func (ce *ClientExt) RemnawaveSettings() *RemnawaveSettingsClient {
	return ce.remnawaveSettings
}

// Snippets returns the SnippetsClient.
func (ce *ClientExt) Snippets() *SnippetsClient {
	return ce.snippets
}

// Subscription returns the SubscriptionClient.
func (ce *ClientExt) Subscription() *SubscriptionClient {
	return ce.subscription
}

// SubscriptionPageConfig returns the SubscriptionPageConfigClient.
func (ce *ClientExt) SubscriptionPageConfig() *SubscriptionPageConfigClient {
	return ce.subscriptionPageConfig
}

// SubscriptionSettings returns the SubscriptionSettingsClient.
func (ce *ClientExt) SubscriptionSettings() *SubscriptionSettingsClient {
	return ce.subscriptionSettings
}

// SubscriptionTemplate returns the SubscriptionTemplateClient.
func (ce *ClientExt) SubscriptionTemplate() *SubscriptionTemplateClient {
	return ce.subscriptionTemplate
}

// Subscriptions returns the SubscriptionsClient.
func (ce *ClientExt) Subscriptions() *SubscriptionsClient {
	return ce.subscriptions
}

// System returns the SystemClient.
func (ce *ClientExt) System() *SystemClient {
	return ce.system
}

// TorrentBlockerReports returns the TorrentBlockerReportsClient.
func (ce *ClientExt) TorrentBlockerReports() *TorrentBlockerReportsClient {
	return ce.torrentBlockerReports
}

// UserSubscriptionRequestHistory returns the UserSubscriptionRequestHistoryClient.
func (ce *ClientExt) UserSubscriptionRequestHistory() *UserSubscriptionRequestHistoryClient {
	return ce.userSubscriptionRequestHistory
}

// Users returns the UsersClient.
func (ce *ClientExt) Users() *UsersClient {
	return ce.users
}

// UsersBulkActions returns the UsersBulkActionsClient.
func (ce *ClientExt) UsersBulkActions() *UsersBulkActionsClient {
	return ce.usersBulkActions
}

// ApiTokensClient provides ApiTokens operations.
type ApiTokensClient struct {
	client *Client
}

// NewApiTokensClient creates a new ApiTokensClient.
func NewApiTokensClient(client *Client) *ApiTokensClient {
	return &ApiTokensClient{client: client}
}

// Create calls ApiTokens_create.
func (sc *ApiTokensClient) Create(ctx context.Context, request *CreateApiTokenRequest, options ...RequestOption) (ApiTokensCreateRes, error) {
	return sc.client.ApiTokensCreate(ctx, request, options...)
}

// Delete calls ApiTokens_delete.
func (sc *ApiTokensClient) Delete(ctx context.Context, uuid string, options ...RequestOption) (ApiTokensDeleteRes, error) {
	return sc.client.ApiTokensDelete(ctx, ApiTokensDeleteParams{
		UUID: uuid,
	}, options...)
}

// FindAll calls ApiTokens_findAll.
func (sc *ApiTokensClient) FindAll(ctx context.Context, options ...RequestOption) (ApiTokensFindAllRes, error) {
	return sc.client.ApiTokensFindAll(ctx, options...)
}

// GetScopes calls ApiTokens_getScopes.
func (sc *ApiTokensClient) GetScopes(ctx context.Context, options ...RequestOption) (ApiTokensGetScopesRes, error) {
	return sc.client.ApiTokensGetScopes(ctx, options...)
}

// AuthClient provides Auth operations.
type AuthClient struct {
	client *Client
}

// NewAuthClient creates a new AuthClient.
func NewAuthClient(client *Client) *AuthClient {
	return &AuthClient{client: client}
}

// GetStatus calls Auth_getStatus.
func (sc *AuthClient) GetStatus(ctx context.Context, options ...RequestOption) (AuthGetStatusRes, error) {
	return sc.client.AuthGetStatus(ctx, options...)
}

// Login calls Auth_login.
func (sc *AuthClient) Login(ctx context.Context, request *LoginRequest, options ...RequestOption) (AuthLoginRes, error) {
	return sc.client.AuthLogin(ctx, request, options...)
}

// Oauth2Authorize calls Auth_oauth2Authorize.
func (sc *AuthClient) Oauth2Authorize(ctx context.Context, request *OAuth2AuthorizeRequest, options ...RequestOption) (AuthOauth2AuthorizeRes, error) {
	return sc.client.AuthOauth2Authorize(ctx, request, options...)
}

// Oauth2Callback calls Auth_oauth2Callback.
func (sc *AuthClient) Oauth2Callback(ctx context.Context, request *OAuth2CallbackRequest, options ...RequestOption) (AuthOauth2CallbackRes, error) {
	return sc.client.AuthOauth2Callback(ctx, request, options...)
}

// PasskeyAuthenticationOptions calls Auth_passkeyAuthenticationOptions.
func (sc *AuthClient) PasskeyAuthenticationOptions(ctx context.Context, options ...RequestOption) (AuthPasskeyAuthenticationOptionsRes, error) {
	return sc.client.AuthPasskeyAuthenticationOptions(ctx, options...)
}

// PasskeyAuthenticationVerify calls Auth_passkeyAuthenticationVerify.
func (sc *AuthClient) PasskeyAuthenticationVerify(ctx context.Context, request *PasskeyOptions, options ...RequestOption) (AuthPasskeyAuthenticationVerifyRes, error) {
	return sc.client.AuthPasskeyAuthenticationVerify(ctx, request, options...)
}

// Register calls Auth_register.
func (sc *AuthClient) Register(ctx context.Context, request *RegisterRequest, options ...RequestOption) (AuthRegisterRes, error) {
	return sc.client.AuthRegister(ctx, request, options...)
}

// BandwidthStatsNodesClient provides BandwidthStatsNodes operations.
type BandwidthStatsNodesClient struct {
	client *Client
}

// NewBandwidthStatsNodesClient creates a new BandwidthStatsNodesClient.
func NewBandwidthStatsNodesClient(client *Client) *BandwidthStatsNodesClient {
	return &BandwidthStatsNodesClient{client: client}
}

// GetNodeUserUsage calls BandwidthStatsNodes_getNodeUserUsage.
func (sc *BandwidthStatsNodesClient) GetNodeUserUsage(ctx context.Context, params BandwidthStatsNodesGetNodeUserUsageParams, options ...RequestOption) (BandwidthStatsNodesGetNodeUserUsageRes, error) {
	return sc.client.BandwidthStatsNodesGetNodeUserUsage(ctx, params, options...)
}

// GetStatsNodeUsersUsage calls BandwidthStatsNodes_getStatsNodeUsersUsage.
func (sc *BandwidthStatsNodesClient) GetStatsNodeUsersUsage(ctx context.Context, params BandwidthStatsNodesGetStatsNodeUsersUsageParams, options ...RequestOption) (BandwidthStatsNodesGetStatsNodeUsersUsageRes, error) {
	return sc.client.BandwidthStatsNodesGetStatsNodeUsersUsage(ctx, params, options...)
}

// GetStatsNodesUsersUsage calls BandwidthStatsNodes_getStatsNodesUsersUsage.
func (sc *BandwidthStatsNodesClient) GetStatsNodesUsersUsage(ctx context.Context, request *GetStatsNodesUsersUsageRequest, params BandwidthStatsNodesGetStatsNodesUsersUsageParams, options ...RequestOption) (BandwidthStatsNodesGetStatsNodesUsersUsageRes, error) {
	return sc.client.BandwidthStatsNodesGetStatsNodesUsersUsage(ctx, request, params, options...)
}

// BandwidthStatsUsersClient provides BandwidthStatsUsers operations.
type BandwidthStatsUsersClient struct {
	client *Client
}

// NewBandwidthStatsUsersClient creates a new BandwidthStatsUsersClient.
func NewBandwidthStatsUsersClient(client *Client) *BandwidthStatsUsersClient {
	return &BandwidthStatsUsersClient{client: client}
}

// GetStatsNodesUsage calls BandwidthStatsUsers_getStatsNodesUsage.
func (sc *BandwidthStatsUsersClient) GetStatsNodesUsage(ctx context.Context, params BandwidthStatsUsersGetStatsNodesUsageParams, options ...RequestOption) (BandwidthStatsUsersGetStatsNodesUsageRes, error) {
	return sc.client.BandwidthStatsUsersGetStatsNodesUsage(ctx, params, options...)
}

// GetUserUsageByRange calls BandwidthStatsUsers_getUserUsageByRange.
func (sc *BandwidthStatsUsersClient) GetUserUsageByRange(ctx context.Context, params BandwidthStatsUsersGetUserUsageByRangeParams, options ...RequestOption) (BandwidthStatsUsersGetUserUsageByRangeRes, error) {
	return sc.client.BandwidthStatsUsersGetUserUsageByRange(ctx, params, options...)
}

// ConfigProfileClient provides ConfigProfile operations.
type ConfigProfileClient struct {
	client *Client
}

// NewConfigProfileClient creates a new ConfigProfileClient.
func NewConfigProfileClient(client *Client) *ConfigProfileClient {
	return &ConfigProfileClient{client: client}
}

// CreateConfigProfile calls ConfigProfile_createConfigProfile.
func (sc *ConfigProfileClient) CreateConfigProfile(ctx context.Context, request *CreateConfigProfileRequest, options ...RequestOption) (ConfigProfileCreateConfigProfileRes, error) {
	return sc.client.ConfigProfileCreateConfigProfile(ctx, request, options...)
}

// DeleteConfigProfileByUuid calls ConfigProfile_deleteConfigProfileByUuid.
func (sc *ConfigProfileClient) DeleteConfigProfileByUuid(ctx context.Context, uuid string, options ...RequestOption) (ConfigProfileDeleteConfigProfileByUuidRes, error) {
	return sc.client.ConfigProfileDeleteConfigProfileByUuid(ctx, ConfigProfileDeleteConfigProfileByUuidParams{
		UUID: uuid,
	}, options...)
}

// GetAllInbounds calls ConfigProfile_getAllInbounds.
func (sc *ConfigProfileClient) GetAllInbounds(ctx context.Context, options ...RequestOption) (ConfigProfileGetAllInboundsRes, error) {
	return sc.client.ConfigProfileGetAllInbounds(ctx, options...)
}

// GetComputedConfigProfileByUuid calls ConfigProfile_getComputedConfigProfileByUuid.
func (sc *ConfigProfileClient) GetComputedConfigProfileByUuid(ctx context.Context, uuid string, options ...RequestOption) (ConfigProfileGetComputedConfigProfileByUuidRes, error) {
	return sc.client.ConfigProfileGetComputedConfigProfileByUuid(ctx, ConfigProfileGetComputedConfigProfileByUuidParams{
		UUID: uuid,
	}, options...)
}

// GetConfigProfileByUuid calls ConfigProfile_getConfigProfileByUuid.
func (sc *ConfigProfileClient) GetConfigProfileByUuid(ctx context.Context, uuid string, options ...RequestOption) (ConfigProfileGetConfigProfileByUuidRes, error) {
	return sc.client.ConfigProfileGetConfigProfileByUuid(ctx, ConfigProfileGetConfigProfileByUuidParams{
		UUID: uuid,
	}, options...)
}

// GetConfigProfiles calls ConfigProfile_getConfigProfiles.
func (sc *ConfigProfileClient) GetConfigProfiles(ctx context.Context, options ...RequestOption) (ConfigProfileGetConfigProfilesRes, error) {
	return sc.client.ConfigProfileGetConfigProfiles(ctx, options...)
}

// GetInboundsByProfileUuid calls ConfigProfile_getInboundsByProfileUuid.
func (sc *ConfigProfileClient) GetInboundsByProfileUuid(ctx context.Context, uuid string, options ...RequestOption) (ConfigProfileGetInboundsByProfileUuidRes, error) {
	return sc.client.ConfigProfileGetInboundsByProfileUuid(ctx, ConfigProfileGetInboundsByProfileUuidParams{
		UUID: uuid,
	}, options...)
}

// ReorderConfigProfiles calls ConfigProfile_reorderConfigProfiles.
func (sc *ConfigProfileClient) ReorderConfigProfiles(ctx context.Context, request *ReorderRequest, options ...RequestOption) (ConfigProfileReorderConfigProfilesRes, error) {
	return sc.client.ConfigProfileReorderConfigProfiles(ctx, request, options...)
}

// UpdateConfigProfile calls ConfigProfile_updateConfigProfile.
func (sc *ConfigProfileClient) UpdateConfigProfile(ctx context.Context, request *UpdateConfigProfileRequest, options ...RequestOption) (ConfigProfileUpdateConfigProfileRes, error) {
	return sc.client.ConfigProfileUpdateConfigProfile(ctx, request, options...)
}

// ExternalSquadClient provides ExternalSquad operations.
type ExternalSquadClient struct {
	client *Client
}

// NewExternalSquadClient creates a new ExternalSquadClient.
func NewExternalSquadClient(client *Client) *ExternalSquadClient {
	return &ExternalSquadClient{client: client}
}

// AddUsersToExternalSquad calls ExternalSquad_addUsersToExternalSquad.
func (sc *ExternalSquadClient) AddUsersToExternalSquad(ctx context.Context, uuid string, options ...RequestOption) (ExternalSquadAddUsersToExternalSquadRes, error) {
	return sc.client.ExternalSquadAddUsersToExternalSquad(ctx, ExternalSquadAddUsersToExternalSquadParams{
		UUID: uuid,
	}, options...)
}

// CreateExternalSquad calls ExternalSquad_createExternalSquad.
func (sc *ExternalSquadClient) CreateExternalSquad(ctx context.Context, request *CreateExternalSquadRequest, options ...RequestOption) (ExternalSquadCreateExternalSquadRes, error) {
	return sc.client.ExternalSquadCreateExternalSquad(ctx, request, options...)
}

// DeleteExternalSquad calls ExternalSquad_deleteExternalSquad.
func (sc *ExternalSquadClient) DeleteExternalSquad(ctx context.Context, uuid string, options ...RequestOption) (ExternalSquadDeleteExternalSquadRes, error) {
	return sc.client.ExternalSquadDeleteExternalSquad(ctx, ExternalSquadDeleteExternalSquadParams{
		UUID: uuid,
	}, options...)
}

// GetExternalSquadByUuid calls ExternalSquad_getExternalSquadByUuid.
func (sc *ExternalSquadClient) GetExternalSquadByUuid(ctx context.Context, uuid string, options ...RequestOption) (ExternalSquadGetExternalSquadByUuidRes, error) {
	return sc.client.ExternalSquadGetExternalSquadByUuid(ctx, ExternalSquadGetExternalSquadByUuidParams{
		UUID: uuid,
	}, options...)
}

// GetExternalSquads calls ExternalSquad_getExternalSquads.
func (sc *ExternalSquadClient) GetExternalSquads(ctx context.Context, options ...RequestOption) (ExternalSquadGetExternalSquadsRes, error) {
	return sc.client.ExternalSquadGetExternalSquads(ctx, options...)
}

// RemoveUsersFromExternalSquad calls ExternalSquad_removeUsersFromExternalSquad.
func (sc *ExternalSquadClient) RemoveUsersFromExternalSquad(ctx context.Context, uuid string, options ...RequestOption) (ExternalSquadRemoveUsersFromExternalSquadRes, error) {
	return sc.client.ExternalSquadRemoveUsersFromExternalSquad(ctx, ExternalSquadRemoveUsersFromExternalSquadParams{
		UUID: uuid,
	}, options...)
}

// ReorderExternalSquads calls ExternalSquad_reorderExternalSquads.
func (sc *ExternalSquadClient) ReorderExternalSquads(ctx context.Context, request *ReorderRequest, options ...RequestOption) (ExternalSquadReorderExternalSquadsRes, error) {
	return sc.client.ExternalSquadReorderExternalSquads(ctx, request, options...)
}

// UpdateExternalSquad calls ExternalSquad_updateExternalSquad.
func (sc *ExternalSquadClient) UpdateExternalSquad(ctx context.Context, request *UpdateExternalSquadRequest, options ...RequestOption) (ExternalSquadUpdateExternalSquadRes, error) {
	return sc.client.ExternalSquadUpdateExternalSquad(ctx, request, options...)
}

// HostsClient provides Hosts operations.
type HostsClient struct {
	client *Client
}

// NewHostsClient creates a new HostsClient.
func NewHostsClient(client *Client) *HostsClient {
	return &HostsClient{client: client}
}

// CreateHost calls Hosts_createHost.
func (sc *HostsClient) CreateHost(ctx context.Context, request *CreateHostRequest, options ...RequestOption) (HostsCreateHostRes, error) {
	return sc.client.HostsCreateHost(ctx, request, options...)
}

// DeleteHost calls Hosts_deleteHost.
func (sc *HostsClient) DeleteHost(ctx context.Context, uuid string, options ...RequestOption) (HostsDeleteHostRes, error) {
	return sc.client.HostsDeleteHost(ctx, HostsDeleteHostParams{
		UUID: uuid,
	}, options...)
}

// GetAllHostTags calls Hosts_getAllHostTags.
func (sc *HostsClient) GetAllHostTags(ctx context.Context, options ...RequestOption) (HostsGetAllHostTagsRes, error) {
	return sc.client.HostsGetAllHostTags(ctx, options...)
}

// GetAllHosts calls Hosts_getAllHosts.
func (sc *HostsClient) GetAllHosts(ctx context.Context, options ...RequestOption) (HostsGetAllHostsRes, error) {
	return sc.client.HostsGetAllHosts(ctx, options...)
}

// GetOneHost calls Hosts_getOneHost.
func (sc *HostsClient) GetOneHost(ctx context.Context, uuid string, options ...RequestOption) (HostsGetOneHostRes, error) {
	return sc.client.HostsGetOneHost(ctx, HostsGetOneHostParams{
		UUID: uuid,
	}, options...)
}

// ReorderHosts calls Hosts_reorderHosts.
func (sc *HostsClient) ReorderHosts(ctx context.Context, request *ReorderHostRequest, options ...RequestOption) (HostsReorderHostsRes, error) {
	return sc.client.HostsReorderHosts(ctx, request, options...)
}

// UpdateHost calls Hosts_updateHost.
func (sc *HostsClient) UpdateHost(ctx context.Context, request *UpdateHostRequest, options ...RequestOption) (HostsUpdateHostRes, error) {
	return sc.client.HostsUpdateHost(ctx, request, options...)
}

// HostsBulkActionsClient provides HostsBulkActions operations.
type HostsBulkActionsClient struct {
	client *Client
}

// NewHostsBulkActionsClient creates a new HostsBulkActionsClient.
func NewHostsBulkActionsClient(client *Client) *HostsBulkActionsClient {
	return &HostsBulkActionsClient{client: client}
}

// DeleteHosts calls HostsBulkActions_deleteHosts.
func (sc *HostsBulkActionsClient) DeleteHosts(ctx context.Context, request *BulkUuidsRequest2, options ...RequestOption) (HostsBulkActionsDeleteHostsRes, error) {
	return sc.client.HostsBulkActionsDeleteHosts(ctx, request, options...)
}

// DisableHosts calls HostsBulkActions_disableHosts.
func (sc *HostsBulkActionsClient) DisableHosts(ctx context.Context, request *BulkUuidsRequest2, options ...RequestOption) (HostsBulkActionsDisableHostsRes, error) {
	return sc.client.HostsBulkActionsDisableHosts(ctx, request, options...)
}

// EnableHosts calls HostsBulkActions_enableHosts.
func (sc *HostsBulkActionsClient) EnableHosts(ctx context.Context, request *BulkUuidsRequest2, options ...RequestOption) (HostsBulkActionsEnableHostsRes, error) {
	return sc.client.HostsBulkActionsEnableHosts(ctx, request, options...)
}

// SetPortToHosts calls HostsBulkActions_setPortToHosts.
func (sc *HostsBulkActionsClient) SetPortToHosts(ctx context.Context, request *UpdateManyHostsRequest, options ...RequestOption) (HostsBulkActionsSetPortToHostsRes, error) {
	return sc.client.HostsBulkActionsSetPortToHosts(ctx, request, options...)
}

// HwidUserDevicesClient provides HwidUserDevices operations.
type HwidUserDevicesClient struct {
	client *Client
}

// NewHwidUserDevicesClient creates a new HwidUserDevicesClient.
func NewHwidUserDevicesClient(client *Client) *HwidUserDevicesClient {
	return &HwidUserDevicesClient{client: client}
}

// CreateUserHwidDevice calls HwidUserDevices_createUserHwidDevice.
func (sc *HwidUserDevicesClient) CreateUserHwidDevice(ctx context.Context, request *CreateUserHwidDeviceRequest, options ...RequestOption) (HwidUserDevicesCreateUserHwidDeviceRes, error) {
	return sc.client.HwidUserDevicesCreateUserHwidDevice(ctx, request, options...)
}

// DeleteAllUserHwidDevices calls HwidUserDevices_deleteAllUserHwidDevices.
func (sc *HwidUserDevicesClient) DeleteAllUserHwidDevices(ctx context.Context, request *DeleteAllUserHwidDevicesRequest, options ...RequestOption) (HwidUserDevicesDeleteAllUserHwidDevicesRes, error) {
	return sc.client.HwidUserDevicesDeleteAllUserHwidDevices(ctx, request, options...)
}

// DeleteUserHwidDevice calls HwidUserDevices_deleteUserHwidDevice.
func (sc *HwidUserDevicesClient) DeleteUserHwidDevice(ctx context.Context, request *DeleteUserHwidDeviceRequest, options ...RequestOption) (HwidUserDevicesDeleteUserHwidDeviceRes, error) {
	return sc.client.HwidUserDevicesDeleteUserHwidDevice(ctx, request, options...)
}

// GetAllUsers calls HwidUserDevices_getAllUsers.
func (sc *HwidUserDevicesClient) GetAllUsers(ctx context.Context, size int, start int, options ...RequestOption) (HwidUserDevicesGetAllUsersRes, error) {
	return sc.client.HwidUserDevicesGetAllUsers(ctx, HwidUserDevicesGetAllUsersParams{
		Size: NewOptInt(size),
		Start: NewOptInt(start),
	}, options...)
}

// GetHwidDevicesStats calls HwidUserDevices_getHwidDevicesStats.
func (sc *HwidUserDevicesClient) GetHwidDevicesStats(ctx context.Context, options ...RequestOption) (HwidUserDevicesGetHwidDevicesStatsRes, error) {
	return sc.client.HwidUserDevicesGetHwidDevicesStats(ctx, options...)
}

// GetTopUsersByHwidDevices calls HwidUserDevices_getTopUsersByHwidDevices.
func (sc *HwidUserDevicesClient) GetTopUsersByHwidDevices(ctx context.Context, size int, start int, options ...RequestOption) (HwidUserDevicesGetTopUsersByHwidDevicesRes, error) {
	return sc.client.HwidUserDevicesGetTopUsersByHwidDevices(ctx, HwidUserDevicesGetTopUsersByHwidDevicesParams{
		Size: NewOptInt(size),
		Start: NewOptInt(start),
	}, options...)
}

// GetUserHwidDevices calls HwidUserDevices_getUserHwidDevices.
func (sc *HwidUserDevicesClient) GetUserHwidDevices(ctx context.Context, useruuid string, options ...RequestOption) (HwidUserDevicesGetUserHwidDevicesRes, error) {
	return sc.client.HwidUserDevicesGetUserHwidDevices(ctx, HwidUserDevicesGetUserHwidDevicesParams{
		UserUuid: useruuid,
	}, options...)
}

// InfraBillingClient provides InfraBilling operations.
type InfraBillingClient struct {
	client *Client
}

// NewInfraBillingClient creates a new InfraBillingClient.
func NewInfraBillingClient(client *Client) *InfraBillingClient {
	return &InfraBillingClient{client: client}
}

// CreateInfraBillingHistoryRecord calls InfraBilling_createInfraBillingHistoryRecord.
func (sc *InfraBillingClient) CreateInfraBillingHistoryRecord(ctx context.Context, request *CreateInfraBillingHistoryRecordRequest, options ...RequestOption) (InfraBillingCreateInfraBillingHistoryRecordRes, error) {
	return sc.client.InfraBillingCreateInfraBillingHistoryRecord(ctx, request, options...)
}

// CreateInfraBillingNode calls InfraBilling_createInfraBillingNode.
func (sc *InfraBillingClient) CreateInfraBillingNode(ctx context.Context, request *CreateInfraBillingNodeRequest, options ...RequestOption) (InfraBillingCreateInfraBillingNodeRes, error) {
	return sc.client.InfraBillingCreateInfraBillingNode(ctx, request, options...)
}

// CreateInfraProvider calls InfraBilling_createInfraProvider.
func (sc *InfraBillingClient) CreateInfraProvider(ctx context.Context, request *CreateInfraProviderRequest, options ...RequestOption) (InfraBillingCreateInfraProviderRes, error) {
	return sc.client.InfraBillingCreateInfraProvider(ctx, request, options...)
}

// DeleteInfraBillingHistoryRecordByUuid calls InfraBilling_deleteInfraBillingHistoryRecordByUuid.
func (sc *InfraBillingClient) DeleteInfraBillingHistoryRecordByUuid(ctx context.Context, uuid string, options ...RequestOption) (InfraBillingDeleteInfraBillingHistoryRecordByUuidRes, error) {
	return sc.client.InfraBillingDeleteInfraBillingHistoryRecordByUuid(ctx, InfraBillingDeleteInfraBillingHistoryRecordByUuidParams{
		UUID: uuid,
	}, options...)
}

// DeleteInfraBillingNodeByUuid calls InfraBilling_deleteInfraBillingNodeByUuid.
func (sc *InfraBillingClient) DeleteInfraBillingNodeByUuid(ctx context.Context, uuid string, options ...RequestOption) (InfraBillingDeleteInfraBillingNodeByUuidRes, error) {
	return sc.client.InfraBillingDeleteInfraBillingNodeByUuid(ctx, InfraBillingDeleteInfraBillingNodeByUuidParams{
		UUID: uuid,
	}, options...)
}

// DeleteInfraProviderByUuid calls InfraBilling_deleteInfraProviderByUuid.
func (sc *InfraBillingClient) DeleteInfraProviderByUuid(ctx context.Context, uuid string, options ...RequestOption) (InfraBillingDeleteInfraProviderByUuidRes, error) {
	return sc.client.InfraBillingDeleteInfraProviderByUuid(ctx, InfraBillingDeleteInfraProviderByUuidParams{
		UUID: uuid,
	}, options...)
}

// GetBillingNodes calls InfraBilling_getBillingNodes.
func (sc *InfraBillingClient) GetBillingNodes(ctx context.Context, options ...RequestOption) (InfraBillingGetBillingNodesRes, error) {
	return sc.client.InfraBillingGetBillingNodes(ctx, options...)
}

// GetInfraBillingHistoryRecords calls InfraBilling_getInfraBillingHistoryRecords.
func (sc *InfraBillingClient) GetInfraBillingHistoryRecords(ctx context.Context, options ...RequestOption) (InfraBillingGetInfraBillingHistoryRecordsRes, error) {
	return sc.client.InfraBillingGetInfraBillingHistoryRecords(ctx, options...)
}

// GetInfraProviderByUuid calls InfraBilling_getInfraProviderByUuid.
func (sc *InfraBillingClient) GetInfraProviderByUuid(ctx context.Context, uuid string, options ...RequestOption) (InfraBillingGetInfraProviderByUuidRes, error) {
	return sc.client.InfraBillingGetInfraProviderByUuid(ctx, InfraBillingGetInfraProviderByUuidParams{
		UUID: uuid,
	}, options...)
}

// GetInfraProviders calls InfraBilling_getInfraProviders.
func (sc *InfraBillingClient) GetInfraProviders(ctx context.Context, options ...RequestOption) (InfraBillingGetInfraProvidersRes, error) {
	return sc.client.InfraBillingGetInfraProviders(ctx, options...)
}

// UpdateInfraBillingNode calls InfraBilling_updateInfraBillingNode.
func (sc *InfraBillingClient) UpdateInfraBillingNode(ctx context.Context, request *UpdateInfraBillingNodeRequest, options ...RequestOption) (InfraBillingUpdateInfraBillingNodeRes, error) {
	return sc.client.InfraBillingUpdateInfraBillingNode(ctx, request, options...)
}

// UpdateInfraProvider calls InfraBilling_updateInfraProvider.
func (sc *InfraBillingClient) UpdateInfraProvider(ctx context.Context, request *UpdateInfraProviderRequest, options ...RequestOption) (InfraBillingUpdateInfraProviderRes, error) {
	return sc.client.InfraBillingUpdateInfraProvider(ctx, request, options...)
}

// InternalSquadClient provides InternalSquad operations.
type InternalSquadClient struct {
	client *Client
}

// NewInternalSquadClient creates a new InternalSquadClient.
func NewInternalSquadClient(client *Client) *InternalSquadClient {
	return &InternalSquadClient{client: client}
}

// AddUsersToInternalSquad calls InternalSquad_addUsersToInternalSquad.
func (sc *InternalSquadClient) AddUsersToInternalSquad(ctx context.Context, uuid string, options ...RequestOption) (InternalSquadAddUsersToInternalSquadRes, error) {
	return sc.client.InternalSquadAddUsersToInternalSquad(ctx, InternalSquadAddUsersToInternalSquadParams{
		UUID: uuid,
	}, options...)
}

// CreateInternalSquad calls InternalSquad_createInternalSquad.
func (sc *InternalSquadClient) CreateInternalSquad(ctx context.Context, request *CreateInternalSquadRequest, options ...RequestOption) (InternalSquadCreateInternalSquadRes, error) {
	return sc.client.InternalSquadCreateInternalSquad(ctx, request, options...)
}

// DeleteInternalSquad calls InternalSquad_deleteInternalSquad.
func (sc *InternalSquadClient) DeleteInternalSquad(ctx context.Context, uuid string, options ...RequestOption) (InternalSquadDeleteInternalSquadRes, error) {
	return sc.client.InternalSquadDeleteInternalSquad(ctx, InternalSquadDeleteInternalSquadParams{
		UUID: uuid,
	}, options...)
}

// GetInternalSquadAccessibleNodes calls InternalSquad_getInternalSquadAccessibleNodes.
func (sc *InternalSquadClient) GetInternalSquadAccessibleNodes(ctx context.Context, uuid string, options ...RequestOption) (InternalSquadGetInternalSquadAccessibleNodesRes, error) {
	return sc.client.InternalSquadGetInternalSquadAccessibleNodes(ctx, InternalSquadGetInternalSquadAccessibleNodesParams{
		UUID: uuid,
	}, options...)
}

// GetInternalSquadByUuid calls InternalSquad_getInternalSquadByUuid.
func (sc *InternalSquadClient) GetInternalSquadByUuid(ctx context.Context, uuid string, options ...RequestOption) (InternalSquadGetInternalSquadByUuidRes, error) {
	return sc.client.InternalSquadGetInternalSquadByUuid(ctx, InternalSquadGetInternalSquadByUuidParams{
		UUID: uuid,
	}, options...)
}

// GetInternalSquads calls InternalSquad_getInternalSquads.
func (sc *InternalSquadClient) GetInternalSquads(ctx context.Context, options ...RequestOption) (InternalSquadGetInternalSquadsRes, error) {
	return sc.client.InternalSquadGetInternalSquads(ctx, options...)
}

// RemoveUsersFromInternalSquad calls InternalSquad_removeUsersFromInternalSquad.
func (sc *InternalSquadClient) RemoveUsersFromInternalSquad(ctx context.Context, uuid string, options ...RequestOption) (InternalSquadRemoveUsersFromInternalSquadRes, error) {
	return sc.client.InternalSquadRemoveUsersFromInternalSquad(ctx, InternalSquadRemoveUsersFromInternalSquadParams{
		UUID: uuid,
	}, options...)
}

// ReorderInternalSquads calls InternalSquad_reorderInternalSquads.
func (sc *InternalSquadClient) ReorderInternalSquads(ctx context.Context, request *ReorderRequest, options ...RequestOption) (InternalSquadReorderInternalSquadsRes, error) {
	return sc.client.InternalSquadReorderInternalSquads(ctx, request, options...)
}

// UpdateInternalSquad calls InternalSquad_updateInternalSquad.
func (sc *InternalSquadClient) UpdateInternalSquad(ctx context.Context, request *UpdateInternalSquadRequest, options ...RequestOption) (InternalSquadUpdateInternalSquadRes, error) {
	return sc.client.InternalSquadUpdateInternalSquad(ctx, request, options...)
}

// IpControlClient provides IpControl operations.
type IpControlClient struct {
	client *Client
}

// NewIpControlClient creates a new IpControlClient.
func NewIpControlClient(client *Client) *IpControlClient {
	return &IpControlClient{client: client}
}

// DropConnections calls IpControl_dropConnections.
func (sc *IpControlClient) DropConnections(ctx context.Context, request *DropConnectionsRequest, options ...RequestOption) (IpControlDropConnectionsRes, error) {
	return sc.client.IpControlDropConnections(ctx, request, options...)
}

// FetchUserIps calls IpControl_fetchUserIps.
func (sc *IpControlClient) FetchUserIps(ctx context.Context, uuid string, options ...RequestOption) (IpControlFetchUserIpsRes, error) {
	return sc.client.IpControlFetchUserIps(ctx, IpControlFetchUserIpsParams{
		UUID: uuid,
	}, options...)
}

// FetchUsersIps calls IpControl_fetchUsersIps.
func (sc *IpControlClient) FetchUsersIps(ctx context.Context, nodeuuid string, options ...RequestOption) (IpControlFetchUsersIpsRes, error) {
	return sc.client.IpControlFetchUsersIps(ctx, IpControlFetchUsersIpsParams{
		NodeUuid: nodeuuid,
	}, options...)
}

// GetFetchIpsResult calls IpControl_getFetchIpsResult.
func (sc *IpControlClient) GetFetchIpsResult(ctx context.Context, jobid string, options ...RequestOption) (IpControlGetFetchIpsResultRes, error) {
	return sc.client.IpControlGetFetchIpsResult(ctx, IpControlGetFetchIpsResultParams{
		JobId: jobid,
	}, options...)
}

// GetFetchUsersIpsResult calls IpControl_getFetchUsersIpsResult.
func (sc *IpControlClient) GetFetchUsersIpsResult(ctx context.Context, jobid string, options ...RequestOption) (IpControlGetFetchUsersIpsResultRes, error) {
	return sc.client.IpControlGetFetchUsersIpsResult(ctx, IpControlGetFetchUsersIpsResultParams{
		JobId: jobid,
	}, options...)
}

// KeygenClient provides Keygen operations.
type KeygenClient struct {
	client *Client
}

// NewKeygenClient creates a new KeygenClient.
func NewKeygenClient(client *Client) *KeygenClient {
	return &KeygenClient{client: client}
}

// GenerateKey calls Keygen_generateKey.
func (sc *KeygenClient) GenerateKey(ctx context.Context, options ...RequestOption) (KeygenGenerateKeyRes, error) {
	return sc.client.KeygenGenerateKey(ctx, options...)
}

// MetadataClient provides Metadata operations.
type MetadataClient struct {
	client *Client
}

// NewMetadataClient creates a new MetadataClient.
func NewMetadataClient(client *Client) *MetadataClient {
	return &MetadataClient{client: client}
}

// GetNodeMetadata calls Metadata_getNodeMetadata.
func (sc *MetadataClient) GetNodeMetadata(ctx context.Context, uuid string, options ...RequestOption) (MetadataGetNodeMetadataRes, error) {
	return sc.client.MetadataGetNodeMetadata(ctx, MetadataGetNodeMetadataParams{
		UUID: uuid,
	}, options...)
}

// GetUserMetadata calls Metadata_getUserMetadata.
func (sc *MetadataClient) GetUserMetadata(ctx context.Context, uuid string, options ...RequestOption) (MetadataGetUserMetadataRes, error) {
	return sc.client.MetadataGetUserMetadata(ctx, MetadataGetUserMetadataParams{
		UUID: uuid,
	}, options...)
}

// UpsertNodeMetadata calls Metadata_upsertNodeMetadata.
func (sc *MetadataClient) UpsertNodeMetadata(ctx context.Context, request *UpsertUserMetadataRequestBodyRequest, uuid string, options ...RequestOption) (MetadataUpsertNodeMetadataRes, error) {
	return sc.client.MetadataUpsertNodeMetadata(ctx, request, MetadataUpsertNodeMetadataParams{
		UUID: uuid,
	}, options...)
}

// UpsertUserMetadata calls Metadata_upsertUserMetadata.
func (sc *MetadataClient) UpsertUserMetadata(ctx context.Context, request *UpsertUserMetadataRequestBodyRequest, uuid string, options ...RequestOption) (MetadataUpsertUserMetadataRes, error) {
	return sc.client.MetadataUpsertUserMetadata(ctx, request, MetadataUpsertUserMetadataParams{
		UUID: uuid,
	}, options...)
}

// NodePluginClient provides NodePlugin operations.
type NodePluginClient struct {
	client *Client
}

// NewNodePluginClient creates a new NodePluginClient.
func NewNodePluginClient(client *Client) *NodePluginClient {
	return &NodePluginClient{client: client}
}

// CloneNodePlugin calls NodePlugin_cloneNodePlugin.
func (sc *NodePluginClient) CloneNodePlugin(ctx context.Context, request *CloneNodePluginRequestRequest, options ...RequestOption) (NodePluginCloneNodePluginRes, error) {
	return sc.client.NodePluginCloneNodePlugin(ctx, request, options...)
}

// CreateConfig calls NodePlugin_createConfig.
func (sc *NodePluginClient) CreateConfig(ctx context.Context, request *CreateNodePluginRequest, options ...RequestOption) (NodePluginCreateConfigRes, error) {
	return sc.client.NodePluginCreateConfig(ctx, request, options...)
}

// DeleteConfig calls NodePlugin_deleteConfig.
func (sc *NodePluginClient) DeleteConfig(ctx context.Context, uuid string, options ...RequestOption) (NodePluginDeleteConfigRes, error) {
	return sc.client.NodePluginDeleteConfig(ctx, NodePluginDeleteConfigParams{
		UUID: uuid,
	}, options...)
}

// GetAllConfigs calls NodePlugin_getAllConfigs.
func (sc *NodePluginClient) GetAllConfigs(ctx context.Context, options ...RequestOption) (NodePluginGetAllConfigsRes, error) {
	return sc.client.NodePluginGetAllConfigs(ctx, options...)
}

// GetConfigByUuid calls NodePlugin_getConfigByUuid.
func (sc *NodePluginClient) GetConfigByUuid(ctx context.Context, uuid string, options ...RequestOption) (NodePluginGetConfigByUuidRes, error) {
	return sc.client.NodePluginGetConfigByUuid(ctx, NodePluginGetConfigByUuidParams{
		UUID: uuid,
	}, options...)
}

// PluginExecutor calls NodePlugin_pluginExecutor.
func (sc *NodePluginClient) PluginExecutor(ctx context.Context, request *PluginExecutorRequest, options ...RequestOption) (NodePluginPluginExecutorRes, error) {
	return sc.client.NodePluginPluginExecutor(ctx, request, options...)
}

// ReorderNodePlugins calls NodePlugin_reorderNodePlugins.
func (sc *NodePluginClient) ReorderNodePlugins(ctx context.Context, request *ReorderRequest, options ...RequestOption) (NodePluginReorderNodePluginsRes, error) {
	return sc.client.NodePluginReorderNodePlugins(ctx, request, options...)
}

// UpdateConfig calls NodePlugin_updateConfig.
func (sc *NodePluginClient) UpdateConfig(ctx context.Context, request *UpdateNodePluginRequest, options ...RequestOption) (NodePluginUpdateConfigRes, error) {
	return sc.client.NodePluginUpdateConfig(ctx, request, options...)
}

// NodesClient provides Nodes operations.
type NodesClient struct {
	client *Client
}

// NewNodesClient creates a new NodesClient.
func NewNodesClient(client *Client) *NodesClient {
	return &NodesClient{client: client}
}

// BulkNodesActions calls Nodes_bulkNodesActions.
func (sc *NodesClient) BulkNodesActions(ctx context.Context, request *BulkNodesActionsRequest, options ...RequestOption) (NodesBulkNodesActionsRes, error) {
	return sc.client.NodesBulkNodesActions(ctx, request, options...)
}

// BulkNodesUpdate calls Nodes_bulkNodesUpdate.
func (sc *NodesClient) BulkNodesUpdate(ctx context.Context, request *BulkNodesUpdateRequest, options ...RequestOption) (NodesBulkNodesUpdateRes, error) {
	return sc.client.NodesBulkNodesUpdate(ctx, request, options...)
}

// CreateNode calls Nodes_createNode.
func (sc *NodesClient) CreateNode(ctx context.Context, request *CreateNodeRequest, options ...RequestOption) (NodesCreateNodeRes, error) {
	return sc.client.NodesCreateNode(ctx, request, options...)
}

// DeleteNode calls Nodes_deleteNode.
func (sc *NodesClient) DeleteNode(ctx context.Context, uuid string, options ...RequestOption) (NodesDeleteNodeRes, error) {
	return sc.client.NodesDeleteNode(ctx, NodesDeleteNodeParams{
		UUID: uuid,
	}, options...)
}

// DisableNode calls Nodes_disableNode.
func (sc *NodesClient) DisableNode(ctx context.Context, uuid string, options ...RequestOption) (NodesDisableNodeRes, error) {
	return sc.client.NodesDisableNode(ctx, NodesDisableNodeParams{
		UUID: uuid,
	}, options...)
}

// EnableNode calls Nodes_enableNode.
func (sc *NodesClient) EnableNode(ctx context.Context, uuid string, options ...RequestOption) (NodesEnableNodeRes, error) {
	return sc.client.NodesEnableNode(ctx, NodesEnableNodeParams{
		UUID: uuid,
	}, options...)
}

// GetAllNodes calls Nodes_getAllNodes.
func (sc *NodesClient) GetAllNodes(ctx context.Context, options ...RequestOption) (NodesGetAllNodesRes, error) {
	return sc.client.NodesGetAllNodes(ctx, options...)
}

// GetAllNodesTags calls Nodes_getAllNodesTags.
func (sc *NodesClient) GetAllNodesTags(ctx context.Context, options ...RequestOption) (NodesGetAllNodesTagsRes, error) {
	return sc.client.NodesGetAllNodesTags(ctx, options...)
}

// GetOneNode calls Nodes_getOneNode.
func (sc *NodesClient) GetOneNode(ctx context.Context, uuid string, options ...RequestOption) (NodesGetOneNodeRes, error) {
	return sc.client.NodesGetOneNode(ctx, NodesGetOneNodeParams{
		UUID: uuid,
	}, options...)
}

// ProfileModification calls Nodes_profileModification.
func (sc *NodesClient) ProfileModification(ctx context.Context, request *ProfileModificationRequest, options ...RequestOption) (NodesProfileModificationRes, error) {
	return sc.client.NodesProfileModification(ctx, request, options...)
}

// ReorderNodes calls Nodes_reorderNodes.
func (sc *NodesClient) ReorderNodes(ctx context.Context, request *ReorderNodeRequest, options ...RequestOption) (NodesReorderNodesRes, error) {
	return sc.client.NodesReorderNodes(ctx, request, options...)
}

// ResetNodeTraffic calls Nodes_resetNodeTraffic.
func (sc *NodesClient) ResetNodeTraffic(ctx context.Context, uuid string, options ...RequestOption) (NodesResetNodeTrafficRes, error) {
	return sc.client.NodesResetNodeTraffic(ctx, NodesResetNodeTrafficParams{
		UUID: uuid,
	}, options...)
}

// RestartAllNodes calls Nodes_restartAllNodes.
func (sc *NodesClient) RestartAllNodes(ctx context.Context, request *NodeRequestBodyRequest, options ...RequestOption) (NodesRestartAllNodesRes, error) {
	return sc.client.NodesRestartAllNodes(ctx, request, options...)
}

// RestartNode calls Nodes_restartNode.
func (sc *NodesClient) RestartNode(ctx context.Context, request *NodeRequestBodyRequest, uuid string, options ...RequestOption) (NodesRestartNodeRes, error) {
	return sc.client.NodesRestartNode(ctx, request, NodesRestartNodeParams{
		UUID: uuid,
	}, options...)
}

// UpdateNode calls Nodes_updateNode.
func (sc *NodesClient) UpdateNode(ctx context.Context, request *UpdateNodeRequest, options ...RequestOption) (NodesUpdateNodeRes, error) {
	return sc.client.NodesUpdateNode(ctx, request, options...)
}

// NodesUsageHistoryClient provides NodesUsageHistory operations.
type NodesUsageHistoryClient struct {
	client *Client
}

// NewNodesUsageHistoryClient creates a new NodesUsageHistoryClient.
func NewNodesUsageHistoryClient(client *Client) *NodesUsageHistoryClient {
	return &NodesUsageHistoryClient{client: client}
}

// GetStatsNodesUsage calls NodesUsageHistory_getStatsNodesUsage.
func (sc *NodesUsageHistoryClient) GetStatsNodesUsage(ctx context.Context, params NodesUsageHistoryGetStatsNodesUsageParams, options ...RequestOption) (NodesUsageHistoryGetStatsNodesUsageRes, error) {
	return sc.client.NodesUsageHistoryGetStatsNodesUsage(ctx, params, options...)
}

// PasskeyClient provides Passkey operations.
type PasskeyClient struct {
	client *Client
}

// NewPasskeyClient creates a new PasskeyClient.
func NewPasskeyClient(client *Client) *PasskeyClient {
	return &PasskeyClient{client: client}
}

// DeletePasskey calls Passkey_deletePasskey.
func (sc *PasskeyClient) DeletePasskey(ctx context.Context, request *DeletePasskeyRequest, options ...RequestOption) (PasskeyDeletePasskeyRes, error) {
	return sc.client.PasskeyDeletePasskey(ctx, request, options...)
}

// GetActivePasskeys calls Passkey_getActivePasskeys.
func (sc *PasskeyClient) GetActivePasskeys(ctx context.Context, options ...RequestOption) (PasskeyGetActivePasskeysRes, error) {
	return sc.client.PasskeyGetActivePasskeys(ctx, options...)
}

// PasskeyRegistrationOptions calls Passkey_passkeyRegistrationOptions.
func (sc *PasskeyClient) PasskeyRegistrationOptions(ctx context.Context, options ...RequestOption) (PasskeyPasskeyRegistrationOptionsRes, error) {
	return sc.client.PasskeyPasskeyRegistrationOptions(ctx, options...)
}

// PasskeyRegistrationVerify calls Passkey_passkeyRegistrationVerify.
func (sc *PasskeyClient) PasskeyRegistrationVerify(ctx context.Context, request *PasskeyOptions, options ...RequestOption) (PasskeyPasskeyRegistrationVerifyRes, error) {
	return sc.client.PasskeyPasskeyRegistrationVerify(ctx, request, options...)
}

// UpdatePasskey calls Passkey_updatePasskey.
func (sc *PasskeyClient) UpdatePasskey(ctx context.Context, request *UpdatePasskeyRequest, options ...RequestOption) (PasskeyUpdatePasskeyRes, error) {
	return sc.client.PasskeyUpdatePasskey(ctx, request, options...)
}

// RemnawaveSettingsClient provides RemnawaveSettings operations.
type RemnawaveSettingsClient struct {
	client *Client
}

// NewRemnawaveSettingsClient creates a new RemnawaveSettingsClient.
func NewRemnawaveSettingsClient(client *Client) *RemnawaveSettingsClient {
	return &RemnawaveSettingsClient{client: client}
}

// GetSettings calls RemnawaveSettings_getSettings.
func (sc *RemnawaveSettingsClient) GetSettings(ctx context.Context, options ...RequestOption) (RemnawaveSettingsGetSettingsRes, error) {
	return sc.client.RemnawaveSettingsGetSettings(ctx, options...)
}

// UpdateSettings calls RemnawaveSettings_updateSettings.
func (sc *RemnawaveSettingsClient) UpdateSettings(ctx context.Context, request *UpdateRemnawaveSettingsRequest, options ...RequestOption) (RemnawaveSettingsUpdateSettingsRes, error) {
	return sc.client.RemnawaveSettingsUpdateSettings(ctx, request, options...)
}

// SnippetsClient provides Snippets operations.
type SnippetsClient struct {
	client *Client
}

// NewSnippetsClient creates a new SnippetsClient.
func NewSnippetsClient(client *Client) *SnippetsClient {
	return &SnippetsClient{client: client}
}

// CreateSnippet calls Snippets_createSnippet.
func (sc *SnippetsClient) CreateSnippet(ctx context.Context, request *SnippetRequest, options ...RequestOption) (SnippetsCreateSnippetRes, error) {
	return sc.client.SnippetsCreateSnippet(ctx, request, options...)
}

// DeleteSnippetByName calls Snippets_deleteSnippetByName.
func (sc *SnippetsClient) DeleteSnippetByName(ctx context.Context, request *DeleteSnippetRequest, options ...RequestOption) (SnippetsDeleteSnippetByNameRes, error) {
	return sc.client.SnippetsDeleteSnippetByName(ctx, request, options...)
}

// GetSnippets calls Snippets_getSnippets.
func (sc *SnippetsClient) GetSnippets(ctx context.Context, options ...RequestOption) (SnippetsGetSnippetsRes, error) {
	return sc.client.SnippetsGetSnippets(ctx, options...)
}

// UpdateSnippet calls Snippets_updateSnippet.
func (sc *SnippetsClient) UpdateSnippet(ctx context.Context, request *SnippetRequest, options ...RequestOption) (SnippetsUpdateSnippetRes, error) {
	return sc.client.SnippetsUpdateSnippet(ctx, request, options...)
}

// SubscriptionClient provides Subscription operations.
type SubscriptionClient struct {
	client *Client
}

// NewSubscriptionClient creates a new SubscriptionClient.
func NewSubscriptionClient(client *Client) *SubscriptionClient {
	return &SubscriptionClient{client: client}
}

// GetSubscription calls Subscription_getSubscription.
func (sc *SubscriptionClient) GetSubscription(ctx context.Context, shortuuid string, options ...RequestOption) (SubscriptionGetSubscriptionOK, error) {
	return sc.client.SubscriptionGetSubscription(ctx, SubscriptionGetSubscriptionParams{
		ShortUuid: shortuuid,
	}, options...)
}

// GetSubscriptionByClientType calls Subscription_getSubscriptionByClientType.
func (sc *SubscriptionClient) GetSubscriptionByClientType(ctx context.Context, params SubscriptionGetSubscriptionByClientTypeParams, options ...RequestOption) (SubscriptionGetSubscriptionByClientTypeOK, error) {
	return sc.client.SubscriptionGetSubscriptionByClientType(ctx, params, options...)
}

// GetSubscriptionInfoByShortUuid calls Subscription_getSubscriptionInfoByShortUuid.
func (sc *SubscriptionClient) GetSubscriptionInfoByShortUuid(ctx context.Context, shortuuid string, options ...RequestOption) (SubscriptionGetSubscriptionInfoByShortUuidRes, error) {
	return sc.client.SubscriptionGetSubscriptionInfoByShortUuid(ctx, SubscriptionGetSubscriptionInfoByShortUuidParams{
		ShortUuid: shortuuid,
	}, options...)
}

// SubscriptionPageConfigClient provides SubscriptionPageConfig operations.
type SubscriptionPageConfigClient struct {
	client *Client
}

// NewSubscriptionPageConfigClient creates a new SubscriptionPageConfigClient.
func NewSubscriptionPageConfigClient(client *Client) *SubscriptionPageConfigClient {
	return &SubscriptionPageConfigClient{client: client}
}

// CloneSubscriptionPageConfig calls SubscriptionPageConfig_cloneSubscriptionPageConfig.
func (sc *SubscriptionPageConfigClient) CloneSubscriptionPageConfig(ctx context.Context, request *CloneNodePluginRequestRequest, options ...RequestOption) (SubscriptionPageConfigCloneSubscriptionPageConfigRes, error) {
	return sc.client.SubscriptionPageConfigCloneSubscriptionPageConfig(ctx, request, options...)
}

// CreateConfig calls SubscriptionPageConfig_createConfig.
func (sc *SubscriptionPageConfigClient) CreateConfig(ctx context.Context, request *CreateSubscriptionPageConfigRequest, options ...RequestOption) (SubscriptionPageConfigCreateConfigRes, error) {
	return sc.client.SubscriptionPageConfigCreateConfig(ctx, request, options...)
}

// DeleteConfig calls SubscriptionPageConfig_deleteConfig.
func (sc *SubscriptionPageConfigClient) DeleteConfig(ctx context.Context, uuid string, options ...RequestOption) (SubscriptionPageConfigDeleteConfigRes, error) {
	return sc.client.SubscriptionPageConfigDeleteConfig(ctx, SubscriptionPageConfigDeleteConfigParams{
		UUID: uuid,
	}, options...)
}

// GetAllConfigs calls SubscriptionPageConfig_getAllConfigs.
func (sc *SubscriptionPageConfigClient) GetAllConfigs(ctx context.Context, options ...RequestOption) (SubscriptionPageConfigGetAllConfigsRes, error) {
	return sc.client.SubscriptionPageConfigGetAllConfigs(ctx, options...)
}

// GetConfigByUuid calls SubscriptionPageConfig_getConfigByUuid.
func (sc *SubscriptionPageConfigClient) GetConfigByUuid(ctx context.Context, uuid string, options ...RequestOption) (SubscriptionPageConfigGetConfigByUuidRes, error) {
	return sc.client.SubscriptionPageConfigGetConfigByUuid(ctx, SubscriptionPageConfigGetConfigByUuidParams{
		UUID: uuid,
	}, options...)
}

// ReorderSubscriptionPageConfigs calls SubscriptionPageConfig_reorderSubscriptionPageConfigs.
func (sc *SubscriptionPageConfigClient) ReorderSubscriptionPageConfigs(ctx context.Context, request *ReorderRequest, options ...RequestOption) (SubscriptionPageConfigReorderSubscriptionPageConfigsRes, error) {
	return sc.client.SubscriptionPageConfigReorderSubscriptionPageConfigs(ctx, request, options...)
}

// UpdateConfig calls SubscriptionPageConfig_updateConfig.
func (sc *SubscriptionPageConfigClient) UpdateConfig(ctx context.Context, request *UpdateSubscriptionPageConfigRequest, options ...RequestOption) (SubscriptionPageConfigUpdateConfigRes, error) {
	return sc.client.SubscriptionPageConfigUpdateConfig(ctx, request, options...)
}

// SubscriptionSettingsClient provides SubscriptionSettings operations.
type SubscriptionSettingsClient struct {
	client *Client
}

// NewSubscriptionSettingsClient creates a new SubscriptionSettingsClient.
func NewSubscriptionSettingsClient(client *Client) *SubscriptionSettingsClient {
	return &SubscriptionSettingsClient{client: client}
}

// GetSettings calls SubscriptionSettings_getSettings.
func (sc *SubscriptionSettingsClient) GetSettings(ctx context.Context, options ...RequestOption) (SubscriptionSettingsGetSettingsRes, error) {
	return sc.client.SubscriptionSettingsGetSettings(ctx, options...)
}

// UpdateSettings calls SubscriptionSettings_updateSettings.
func (sc *SubscriptionSettingsClient) UpdateSettings(ctx context.Context, request *UpdateSubscriptionSettingsRequest, options ...RequestOption) (SubscriptionSettingsUpdateSettingsRes, error) {
	return sc.client.SubscriptionSettingsUpdateSettings(ctx, request, options...)
}

// SubscriptionTemplateClient provides SubscriptionTemplate operations.
type SubscriptionTemplateClient struct {
	client *Client
}

// NewSubscriptionTemplateClient creates a new SubscriptionTemplateClient.
func NewSubscriptionTemplateClient(client *Client) *SubscriptionTemplateClient {
	return &SubscriptionTemplateClient{client: client}
}

// CreateTemplate calls SubscriptionTemplate_createTemplate.
func (sc *SubscriptionTemplateClient) CreateTemplate(ctx context.Context, request *CreateSubscriptionTemplateRequest, options ...RequestOption) (SubscriptionTemplateCreateTemplateRes, error) {
	return sc.client.SubscriptionTemplateCreateTemplate(ctx, request, options...)
}

// DeleteTemplate calls SubscriptionTemplate_deleteTemplate.
func (sc *SubscriptionTemplateClient) DeleteTemplate(ctx context.Context, uuid string, options ...RequestOption) (SubscriptionTemplateDeleteTemplateRes, error) {
	return sc.client.SubscriptionTemplateDeleteTemplate(ctx, SubscriptionTemplateDeleteTemplateParams{
		UUID: uuid,
	}, options...)
}

// GetAllTemplates calls SubscriptionTemplate_getAllTemplates.
func (sc *SubscriptionTemplateClient) GetAllTemplates(ctx context.Context, options ...RequestOption) (SubscriptionTemplateGetAllTemplatesRes, error) {
	return sc.client.SubscriptionTemplateGetAllTemplates(ctx, options...)
}

// GetTemplateByUuid calls SubscriptionTemplate_getTemplateByUuid.
func (sc *SubscriptionTemplateClient) GetTemplateByUuid(ctx context.Context, uuid string, options ...RequestOption) (SubscriptionTemplateGetTemplateByUuidRes, error) {
	return sc.client.SubscriptionTemplateGetTemplateByUuid(ctx, SubscriptionTemplateGetTemplateByUuidParams{
		UUID: uuid,
	}, options...)
}

// ReorderSubscriptionTemplates calls SubscriptionTemplate_reorderSubscriptionTemplates.
func (sc *SubscriptionTemplateClient) ReorderSubscriptionTemplates(ctx context.Context, request *ReorderRequest, options ...RequestOption) (SubscriptionTemplateReorderSubscriptionTemplatesRes, error) {
	return sc.client.SubscriptionTemplateReorderSubscriptionTemplates(ctx, request, options...)
}

// UpdateTemplate calls SubscriptionTemplate_updateTemplate.
func (sc *SubscriptionTemplateClient) UpdateTemplate(ctx context.Context, request *UpdateTemplateRequest, options ...RequestOption) (SubscriptionTemplateUpdateTemplateRes, error) {
	return sc.client.SubscriptionTemplateUpdateTemplate(ctx, request, options...)
}

// SubscriptionsClient provides Subscriptions operations.
type SubscriptionsClient struct {
	client *Client
}

// NewSubscriptionsClient creates a new SubscriptionsClient.
func NewSubscriptionsClient(client *Client) *SubscriptionsClient {
	return &SubscriptionsClient{client: client}
}

// GetAllSubscriptions calls Subscriptions_getAllSubscriptions.
func (sc *SubscriptionsClient) GetAllSubscriptions(ctx context.Context, size int, start int, options ...RequestOption) (SubscriptionsGetAllSubscriptionsRes, error) {
	return sc.client.SubscriptionsGetAllSubscriptions(ctx, SubscriptionsGetAllSubscriptionsParams{
		Size: NewOptInt(size),
		Start: NewOptInt(start),
	}, options...)
}

// GetConnectionKeysByUuid calls Subscriptions_getConnectionKeysByUuid.
func (sc *SubscriptionsClient) GetConnectionKeysByUuid(ctx context.Context, uuid string, options ...RequestOption) (SubscriptionsGetConnectionKeysByUuidRes, error) {
	return sc.client.SubscriptionsGetConnectionKeysByUuid(ctx, SubscriptionsGetConnectionKeysByUuidParams{
		UUID: uuid,
	}, options...)
}

// GetRawSubscriptionByShortUuid calls Subscriptions_getRawSubscriptionByShortUuid.
func (sc *SubscriptionsClient) GetRawSubscriptionByShortUuid(ctx context.Context, withdisabledhosts bool, shortuuid string, options ...RequestOption) (SubscriptionsGetRawSubscriptionByShortUuidRes, error) {
	return sc.client.SubscriptionsGetRawSubscriptionByShortUuid(ctx, SubscriptionsGetRawSubscriptionByShortUuidParams{
		WithDisabledHosts: NewOptBool(withdisabledhosts),
		ShortUuid: shortuuid,
	}, options...)
}

// GetSubpageConfigByShortUuid calls Subscriptions_getSubpageConfigByShortUuid.
func (sc *SubscriptionsClient) GetSubpageConfigByShortUuid(ctx context.Context, request *GetSubpageConfigByShortUuidRequestBody, shortuuid string, options ...RequestOption) (SubscriptionsGetSubpageConfigByShortUuidRes, error) {
	return sc.client.SubscriptionsGetSubpageConfigByShortUuid(ctx, request, SubscriptionsGetSubpageConfigByShortUuidParams{
		ShortUuid: shortuuid,
	}, options...)
}

// GetSubscriptionByShortUuidProtected calls Subscriptions_getSubscriptionByShortUuidProtected.
func (sc *SubscriptionsClient) GetSubscriptionByShortUuidProtected(ctx context.Context, shortuuid string, options ...RequestOption) (SubscriptionsGetSubscriptionByShortUuidProtectedRes, error) {
	return sc.client.SubscriptionsGetSubscriptionByShortUuidProtected(ctx, SubscriptionsGetSubscriptionByShortUuidProtectedParams{
		ShortUuid: shortuuid,
	}, options...)
}

// GetSubscriptionByUsername calls Subscriptions_getSubscriptionByUsername.
func (sc *SubscriptionsClient) GetSubscriptionByUsername(ctx context.Context, username string, options ...RequestOption) (SubscriptionsGetSubscriptionByUsernameRes, error) {
	return sc.client.SubscriptionsGetSubscriptionByUsername(ctx, SubscriptionsGetSubscriptionByUsernameParams{
		Username: username,
	}, options...)
}

// GetSubscriptionByUuid calls Subscriptions_getSubscriptionByUuid.
func (sc *SubscriptionsClient) GetSubscriptionByUuid(ctx context.Context, uuid string, options ...RequestOption) (SubscriptionsGetSubscriptionByUuidRes, error) {
	return sc.client.SubscriptionsGetSubscriptionByUuid(ctx, SubscriptionsGetSubscriptionByUuidParams{
		UUID: uuid,
	}, options...)
}

// SystemClient provides System operations.
type SystemClient struct {
	client *Client
}

// NewSystemClient creates a new SystemClient.
func NewSystemClient(client *Client) *SystemClient {
	return &SystemClient{client: client}
}

// DebugSrrMatcher calls System_debugSrrMatcher.
func (sc *SystemClient) DebugSrrMatcher(ctx context.Context, request *DebugSrrMatcherRequest, options ...RequestOption) (SystemDebugSrrMatcherRes, error) {
	return sc.client.SystemDebugSrrMatcher(ctx, request, options...)
}

// GetBandwidthStats calls System_getBandwidthStats.
func (sc *SystemClient) GetBandwidthStats(ctx context.Context, options ...RequestOption) (SystemGetBandwidthStatsRes, error) {
	return sc.client.SystemGetBandwidthStats(ctx, options...)
}

// GetMetadata calls System_getMetadata.
func (sc *SystemClient) GetMetadata(ctx context.Context, options ...RequestOption) (SystemGetMetadataRes, error) {
	return sc.client.SystemGetMetadata(ctx, options...)
}

// GetNodesMetrics calls System_getNodesMetrics.
func (sc *SystemClient) GetNodesMetrics(ctx context.Context, options ...RequestOption) (SystemGetNodesMetricsRes, error) {
	return sc.client.SystemGetNodesMetrics(ctx, options...)
}

// GetNodesStatistics calls System_getNodesStatistics.
func (sc *SystemClient) GetNodesStatistics(ctx context.Context, options ...RequestOption) (SystemGetNodesStatisticsRes, error) {
	return sc.client.SystemGetNodesStatistics(ctx, options...)
}

// GetRecap calls System_getRecap.
func (sc *SystemClient) GetRecap(ctx context.Context, options ...RequestOption) (SystemGetRecapRes, error) {
	return sc.client.SystemGetRecap(ctx, options...)
}

// GetRemnawaveHealth calls System_getRemnawaveHealth.
func (sc *SystemClient) GetRemnawaveHealth(ctx context.Context, options ...RequestOption) (SystemGetRemnawaveHealthRes, error) {
	return sc.client.SystemGetRemnawaveHealth(ctx, options...)
}

// GetStats calls System_getStats.
func (sc *SystemClient) GetStats(ctx context.Context, options ...RequestOption) (SystemGetStatsRes, error) {
	return sc.client.SystemGetStats(ctx, options...)
}

// GetX25519Keypairs calls System_getX25519Keypairs.
func (sc *SystemClient) GetX25519Keypairs(ctx context.Context, options ...RequestOption) (SystemGetX25519KeypairsRes, error) {
	return sc.client.SystemGetX25519Keypairs(ctx, options...)
}

// TorrentBlockerReportsClient provides TorrentBlockerReports operations.
type TorrentBlockerReportsClient struct {
	client *Client
}

// NewTorrentBlockerReportsClient creates a new TorrentBlockerReportsClient.
func NewTorrentBlockerReportsClient(client *Client) *TorrentBlockerReportsClient {
	return &TorrentBlockerReportsClient{client: client}
}

// GetTorrentBlockerReports calls TorrentBlockerReports_getTorrentBlockerReports.
func (sc *TorrentBlockerReportsClient) GetTorrentBlockerReports(ctx context.Context, size int, start int, options ...RequestOption) (TorrentBlockerReportsGetTorrentBlockerReportsRes, error) {
	return sc.client.TorrentBlockerReportsGetTorrentBlockerReports(ctx, TorrentBlockerReportsGetTorrentBlockerReportsParams{
		Size: NewOptInt(size),
		Start: NewOptInt(start),
	}, options...)
}

// GetTorrentBlockerReportsStats calls TorrentBlockerReports_getTorrentBlockerReportsStats.
func (sc *TorrentBlockerReportsClient) GetTorrentBlockerReportsStats(ctx context.Context, options ...RequestOption) (TorrentBlockerReportsGetTorrentBlockerReportsStatsRes, error) {
	return sc.client.TorrentBlockerReportsGetTorrentBlockerReportsStats(ctx, options...)
}

// TruncateTorrentBlockerReports calls TorrentBlockerReports_truncateTorrentBlockerReports.
func (sc *TorrentBlockerReportsClient) TruncateTorrentBlockerReports(ctx context.Context, options ...RequestOption) (TorrentBlockerReportsTruncateTorrentBlockerReportsRes, error) {
	return sc.client.TorrentBlockerReportsTruncateTorrentBlockerReports(ctx, options...)
}

// UserSubscriptionRequestHistoryClient provides UserSubscriptionRequestHistory operations.
type UserSubscriptionRequestHistoryClient struct {
	client *Client
}

// NewUserSubscriptionRequestHistoryClient creates a new UserSubscriptionRequestHistoryClient.
func NewUserSubscriptionRequestHistoryClient(client *Client) *UserSubscriptionRequestHistoryClient {
	return &UserSubscriptionRequestHistoryClient{client: client}
}

// GetSubscriptionRequestHistory calls UserSubscriptionRequestHistory_getSubscriptionRequestHistory.
func (sc *UserSubscriptionRequestHistoryClient) GetSubscriptionRequestHistory(ctx context.Context, size int, start int, options ...RequestOption) (UserSubscriptionRequestHistoryGetSubscriptionRequestHistoryRes, error) {
	return sc.client.UserSubscriptionRequestHistoryGetSubscriptionRequestHistory(ctx, UserSubscriptionRequestHistoryGetSubscriptionRequestHistoryParams{
		Size: NewOptInt(size),
		Start: NewOptInt(start),
	}, options...)
}

// GetSubscriptionRequestHistoryStats calls UserSubscriptionRequestHistory_getSubscriptionRequestHistoryStats.
func (sc *UserSubscriptionRequestHistoryClient) GetSubscriptionRequestHistoryStats(ctx context.Context, options ...RequestOption) (UserSubscriptionRequestHistoryGetSubscriptionRequestHistoryStatsRes, error) {
	return sc.client.UserSubscriptionRequestHistoryGetSubscriptionRequestHistoryStats(ctx, options...)
}

// UsersClient provides Users operations.
type UsersClient struct {
	client *Client
}

// NewUsersClient creates a new UsersClient.
func NewUsersClient(client *Client) *UsersClient {
	return &UsersClient{client: client}
}

// CreateUser calls Users_createUser.
func (sc *UsersClient) CreateUser(ctx context.Context, request *CreateUserRequest, options ...RequestOption) (UsersCreateUserRes, error) {
	return sc.client.UsersCreateUser(ctx, request, options...)
}

// DeleteUser calls Users_deleteUser.
func (sc *UsersClient) DeleteUser(ctx context.Context, uuid string, options ...RequestOption) (UsersDeleteUserRes, error) {
	return sc.client.UsersDeleteUser(ctx, UsersDeleteUserParams{
		UUID: uuid,
	}, options...)
}

// DisableUser calls Users_disableUser.
func (sc *UsersClient) DisableUser(ctx context.Context, uuid string, options ...RequestOption) (UsersDisableUserRes, error) {
	return sc.client.UsersDisableUser(ctx, UsersDisableUserParams{
		UUID: uuid,
	}, options...)
}

// EnableUser calls Users_enableUser.
func (sc *UsersClient) EnableUser(ctx context.Context, uuid string, options ...RequestOption) (UsersEnableUserRes, error) {
	return sc.client.UsersEnableUser(ctx, UsersEnableUserParams{
		UUID: uuid,
	}, options...)
}

// GetAllTags calls Users_getAllTags.
func (sc *UsersClient) GetAllTags(ctx context.Context, options ...RequestOption) (UsersGetAllTagsRes, error) {
	return sc.client.UsersGetAllTags(ctx, options...)
}

// GetAllUsers calls Users_getAllUsers.
func (sc *UsersClient) GetAllUsers(ctx context.Context, size int, start int, options ...RequestOption) (UsersGetAllUsersRes, error) {
	return sc.client.UsersGetAllUsers(ctx, UsersGetAllUsersParams{
		Size: NewOptInt(size),
		Start: NewOptInt(start),
	}, options...)
}

// GetUserAccessibleNodes calls Users_getUserAccessibleNodes.
func (sc *UsersClient) GetUserAccessibleNodes(ctx context.Context, uuid string, options ...RequestOption) (UsersGetUserAccessibleNodesRes, error) {
	return sc.client.UsersGetUserAccessibleNodes(ctx, UsersGetUserAccessibleNodesParams{
		UUID: uuid,
	}, options...)
}

// GetUserById calls Users_getUserById.
func (sc *UsersClient) GetUserById(ctx context.Context, id string, options ...RequestOption) (UsersGetUserByIdRes, error) {
	return sc.client.UsersGetUserById(ctx, UsersGetUserByIdParams{
		ID: id,
	}, options...)
}

// GetUserByShortUuid calls Users_getUserByShortUuid.
func (sc *UsersClient) GetUserByShortUuid(ctx context.Context, shortuuid string, options ...RequestOption) (UsersGetUserByShortUuidRes, error) {
	return sc.client.UsersGetUserByShortUuid(ctx, UsersGetUserByShortUuidParams{
		ShortUuid: shortuuid,
	}, options...)
}

// GetUserByTelegramId calls Users_getUserByTelegramId.
func (sc *UsersClient) GetUserByTelegramId(ctx context.Context, telegramid string, options ...RequestOption) (UsersGetUserByTelegramIdRes, error) {
	return sc.client.UsersGetUserByTelegramId(ctx, UsersGetUserByTelegramIdParams{
		TelegramId: telegramid,
	}, options...)
}

// GetUserByUsername calls Users_getUserByUsername.
func (sc *UsersClient) GetUserByUsername(ctx context.Context, username string, options ...RequestOption) (UsersGetUserByUsernameRes, error) {
	return sc.client.UsersGetUserByUsername(ctx, UsersGetUserByUsernameParams{
		Username: username,
	}, options...)
}

// GetUserByUuid calls Users_getUserByUuid.
func (sc *UsersClient) GetUserByUuid(ctx context.Context, uuid string, options ...RequestOption) (UsersGetUserByUuidRes, error) {
	return sc.client.UsersGetUserByUuid(ctx, UsersGetUserByUuidParams{
		UUID: uuid,
	}, options...)
}

// GetUserSubscriptionRequestHistory calls Users_getUserSubscriptionRequestHistory.
func (sc *UsersClient) GetUserSubscriptionRequestHistory(ctx context.Context, uuid string, options ...RequestOption) (UsersGetUserSubscriptionRequestHistoryRes, error) {
	return sc.client.UsersGetUserSubscriptionRequestHistory(ctx, UsersGetUserSubscriptionRequestHistoryParams{
		UUID: uuid,
	}, options...)
}

// GetUsersByEmail calls Users_getUsersByEmail.
func (sc *UsersClient) GetUsersByEmail(ctx context.Context, email string, options ...RequestOption) (UsersGetUsersByEmailRes, error) {
	return sc.client.UsersGetUsersByEmail(ctx, UsersGetUsersByEmailParams{
		Email: email,
	}, options...)
}

// GetUsersByTag calls Users_getUsersByTag.
func (sc *UsersClient) GetUsersByTag(ctx context.Context, tag string, options ...RequestOption) (UsersGetUsersByTagRes, error) {
	return sc.client.UsersGetUsersByTag(ctx, UsersGetUsersByTagParams{
		Tag: tag,
	}, options...)
}

// GetUsersStream calls Users_getUsersStream.
func (sc *UsersClient) GetUsersStream(ctx context.Context, size int, cursor string, options ...RequestOption) (UsersGetUsersStreamRes, error) {
	return sc.client.UsersGetUsersStream(ctx, UsersGetUsersStreamParams{
		Size: NewOptInt(size),
		Cursor: NewOptString(cursor),
	}, options...)
}

// ResetUserTraffic calls Users_resetUserTraffic.
func (sc *UsersClient) ResetUserTraffic(ctx context.Context, uuid string, options ...RequestOption) (UsersResetUserTrafficRes, error) {
	return sc.client.UsersResetUserTraffic(ctx, UsersResetUserTrafficParams{
		UUID: uuid,
	}, options...)
}

// ResolveUser calls Users_resolveUser.
func (sc *UsersClient) ResolveUser(ctx context.Context, request *ResolveUserRequestBody, options ...RequestOption) (UsersResolveUserRes, error) {
	return sc.client.UsersResolveUser(ctx, request, options...)
}

// RevokeUserSubscription calls Users_revokeUserSubscription.
func (sc *UsersClient) RevokeUserSubscription(ctx context.Context, request *RevokeUserSubscriptionBody, uuid string, options ...RequestOption) (UsersRevokeUserSubscriptionRes, error) {
	return sc.client.UsersRevokeUserSubscription(ctx, request, UsersRevokeUserSubscriptionParams{
		UUID: uuid,
	}, options...)
}

// UpdateUser calls Users_updateUser.
func (sc *UsersClient) UpdateUser(ctx context.Context, request *UpdateUserRequest, options ...RequestOption) (UsersUpdateUserRes, error) {
	return sc.client.UsersUpdateUser(ctx, request, options...)
}

// UsersBulkActionsClient provides UsersBulkActions operations.
type UsersBulkActionsClient struct {
	client *Client
}

// NewUsersBulkActionsClient creates a new UsersBulkActionsClient.
func NewUsersBulkActionsClient(client *Client) *UsersBulkActionsClient {
	return &UsersBulkActionsClient{client: client}
}

// BulkAllExtendExpirationDate calls UsersBulkActions_bulkAllExtendExpirationDate.
func (sc *UsersBulkActionsClient) BulkAllExtendExpirationDate(ctx context.Context, request *BulkAllExtendExpirationDateRequest, options ...RequestOption) (UsersBulkActionsBulkAllExtendExpirationDateRes, error) {
	return sc.client.UsersBulkActionsBulkAllExtendExpirationDate(ctx, request, options...)
}

// BulkAllResetUserTraffic calls UsersBulkActions_bulkAllResetUserTraffic.
func (sc *UsersBulkActionsClient) BulkAllResetUserTraffic(ctx context.Context, options ...RequestOption) (UsersBulkActionsBulkAllResetUserTrafficRes, error) {
	return sc.client.UsersBulkActionsBulkAllResetUserTraffic(ctx, options...)
}

// BulkDeleteUsers calls UsersBulkActions_bulkDeleteUsers.
func (sc *UsersBulkActionsClient) BulkDeleteUsers(ctx context.Context, request *BulkUuidsRequest, options ...RequestOption) (UsersBulkActionsBulkDeleteUsersRes, error) {
	return sc.client.UsersBulkActionsBulkDeleteUsers(ctx, request, options...)
}

// BulkDeleteUsersByStatus calls UsersBulkActions_bulkDeleteUsersByStatus.
func (sc *UsersBulkActionsClient) BulkDeleteUsersByStatus(ctx context.Context, request *BulkDeleteUsersByStatusRequest, options ...RequestOption) (UsersBulkActionsBulkDeleteUsersByStatusRes, error) {
	return sc.client.UsersBulkActionsBulkDeleteUsersByStatus(ctx, request, options...)
}

// BulkExtendExpirationDate calls UsersBulkActions_bulkExtendExpirationDate.
func (sc *UsersBulkActionsClient) BulkExtendExpirationDate(ctx context.Context, request *BulkExtendExpirationDateRequest, options ...RequestOption) (UsersBulkActionsBulkExtendExpirationDateRes, error) {
	return sc.client.UsersBulkActionsBulkExtendExpirationDate(ctx, request, options...)
}

// BulkResetUserTraffic calls UsersBulkActions_bulkResetUserTraffic.
func (sc *UsersBulkActionsClient) BulkResetUserTraffic(ctx context.Context, request *BulkUuidsRequest, options ...RequestOption) (UsersBulkActionsBulkResetUserTrafficRes, error) {
	return sc.client.UsersBulkActionsBulkResetUserTraffic(ctx, request, options...)
}

// BulkRevokeUsersSubscription calls UsersBulkActions_bulkRevokeUsersSubscription.
func (sc *UsersBulkActionsClient) BulkRevokeUsersSubscription(ctx context.Context, request *BulkUuidsRequest, options ...RequestOption) (UsersBulkActionsBulkRevokeUsersSubscriptionRes, error) {
	return sc.client.UsersBulkActionsBulkRevokeUsersSubscription(ctx, request, options...)
}

// BulkUpdateAllUsers calls UsersBulkActions_bulkUpdateAllUsers.
func (sc *UsersBulkActionsClient) BulkUpdateAllUsers(ctx context.Context, request *BulkAllUpdateUsersRequest, options ...RequestOption) (UsersBulkActionsBulkUpdateAllUsersRes, error) {
	return sc.client.UsersBulkActionsBulkUpdateAllUsers(ctx, request, options...)
}

// BulkUpdateUsers calls UsersBulkActions_bulkUpdateUsers.
func (sc *UsersBulkActionsClient) BulkUpdateUsers(ctx context.Context, request *BulkUpdateUsersRequest, options ...RequestOption) (UsersBulkActionsBulkUpdateUsersRes, error) {
	return sc.client.UsersBulkActionsBulkUpdateUsers(ctx, request, options...)
}

// BulkUpdateUsersInternalSquads calls UsersBulkActions_bulkUpdateUsersInternalSquads.
func (sc *UsersBulkActionsClient) BulkUpdateUsersInternalSquads(ctx context.Context, request *BulkUpdateUsersSquadsRequest, options ...RequestOption) (UsersBulkActionsBulkUpdateUsersInternalSquadsRes, error) {
	return sc.client.UsersBulkActionsBulkUpdateUsersInternalSquads(ctx, request, options...)
}