resources

type ApplicationLoadBalancer struct {
	ionoscloud.ApplicationLoadBalancer
}

type ApplicationLoadBalancerForwardingRule struct {
	ionoscloud.ApplicationLoadBalancerForwardingRule
}

type ApplicationLoadBalancerForwardingRuleProperties struct {
	ionoscloud.ApplicationLoadBalancerForwardingRuleProperties
}

type ApplicationLoadBalancerForwardingRules struct {
	ionoscloud.ApplicationLoadBalancerForwardingRules
}

type ApplicationLoadBalancerHttpRule struct {
	ionoscloud.ApplicationLoadBalancerHttpRule
}

type ApplicationLoadBalancerHttpRuleCondition struct {
	ionoscloud.ApplicationLoadBalancerHttpRuleCondition
}

type ApplicationLoadBalancerProperties struct {
	ionoscloud.ApplicationLoadBalancerProperties
}

type ApplicationLoadBalancerPut struct {
	ionoscloud.ApplicationLoadBalancerPut
}

type ApplicationLoadBalancers struct {
	ionoscloud.ApplicationLoadBalancers
}

type ApplicationLoadBalancersService interface {
	List(datacenterId string) (ApplicationLoadBalancers, *Response, error)
	Get(datacenterId, applicationLoadBalancerId string) (*ApplicationLoadBalancer, *Response, error)
	Create(datacenterId string, input ApplicationLoadBalancer) (*ApplicationLoadBalancer, *Response, error)
	Update(datacenterId, applicationLoadBalancerId string, input ApplicationLoadBalancerProperties) (*ApplicationLoadBalancer, *Response, error)
	Delete(datacenterId, applicationLoadBalancerId string) (*Response, error)
	ListForwardingRules(datacenterId, applicationLoadBalancerId string) (ApplicationLoadBalancerForwardingRules, *Response, error)
	GetForwardingRule(datacenterId, applicationLoadBalancerId, forwardingRuleId string) (*ApplicationLoadBalancerForwardingRule, *Response, error)
	CreateForwardingRule(datacenterId, applicationLoadBalancerId string, input ApplicationLoadBalancerForwardingRule) (*ApplicationLoadBalancerForwardingRule, *Response, error)
	UpdateForwardingRule(datacenterId, applicationLoadBalancerId, forwardingRuleId string, input *ApplicationLoadBalancerForwardingRuleProperties) (*ApplicationLoadBalancerForwardingRule, *Response, error)
	DeleteForwardingRule(datacenterId, applicationLoadBalancerId, forwardingRuleId string) (*Response, error)
	ListFlowLogs(datacenterId, applicationLoadBalancerId string) (FlowLogs, *Response, error)
	GetFlowLog(datacenterId, applicationLoadBalancerId, flowLogId string) (*FlowLog, *Response, error)
	CreateFlowLog(datacenterId, applicationLoadBalancerId string, input FlowLog) (*FlowLog, *Response, error)
	UpdateFlowLog(datacenterId, applicationLoadBalancerId, flowLogId string, input *FlowLogProperties) (*FlowLog, *Response, error)
	DeleteFlowLog(datacenterId, applicationLoadBalancerId, flowLogId string) (*Response, error)
}

type AttachedVolumes struct {
	ionoscloud.AttachedVolumes
}

type BackupUnit struct {
	ionoscloud.BackupUnit
}

type BackupUnitProperties struct {
	ionoscloud.BackupUnitProperties
}

type BackupUnitSSO struct {
	ionoscloud.BackupUnitSSO
}

type BackupUnits struct {
	ionoscloud.BackupUnits
}

type BackupUnitsService interface {
	List() (BackupUnits, *Response, error)
	Get(backupUnitId string) (*BackupUnit, *Response, error)
	GetSsoUrl(backupUnitId string) (*BackupUnitSSO, *Response, error)
	Create(u BackupUnit) (*BackupUnit, *Response, error)
	Update(backupUnitId string, input BackupUnitProperties) (*BackupUnit, *Response, error)
	Delete(backupUnitId string) (*Response, error)
}

type BalancedNics struct {
	ionoscloud.BalancedNics
}

type Cdroms struct {
	ionoscloud.Cdroms
}

type Contract struct {
	ionoscloud.Contract
}

type Contracts struct {
	ionoscloud.Contracts
}

type ContractsService interface {
	Get() (Contracts, *Response, error)
}

type CpuArchitectureProperties struct {
	ionoscloud.CpuArchitectureProperties
}

type Datacenter struct {
	ionoscloud.Datacenter
}

type DatacenterProperties struct {
	ionoscloud.DatacenterProperties
}

type DatacenterPropertiesPut struct {
	ionoscloud.DatacenterPropertiesPut
}

type Datacenters struct {
	ionoscloud.Datacenters
}

type DatacentersService interface {
	List() (Datacenters, *Response, error)
	Get(datacenterId string) (*Datacenter, *Response, error)
	Create(name, description, region string) (*Datacenter, *Response, error)
	Update(datacenterId string, input DatacenterPropertiesPut) (*Datacenter, *Response, error)
	Delete(datacenterId string) (*Response, error)
}

type FTPServerProperties struct {
	Url               string // Server URL without any directory path. Example: ftp-fkb.ionos.com
	Port              int
	SkipVerify        bool           // Skip FTP server certificate verification. WARNING man-in-the-middle attack possible
	ServerCertificate *x509.CertPool // If FTP server uses self signed certificates, put this in tlsConfig. IONOS FTP Servers in prod DON'T need this
	Username          string
	Password          string
}

type FirewallRule struct {
	ionoscloud.FirewallRule
}

type FirewallRuleProperties struct {
	ionoscloud.FirewallruleProperties
}

type FirewallRules struct {
	ionoscloud.FirewallRules
}

type FirewallRulesService interface {
	List(datacenterId, serverId, nicId string) (FirewallRules, *Response, error)
	Get(datacenterId, serverId, nicId, firewallRuleId string) (*FirewallRule, *Response, error)
	Create(datacenterId, serverId, nicId string, input FirewallRule) (*FirewallRule, *Response, error)
	Update(datacenterId, serverId, nicId, firewallRuleId string, input FirewallRuleProperties) (*FirewallRule, *Response, error)
	Delete(datacenterId, serverId, nicId, firewallRuleId string) (*Response, error)
}

type FlowLog struct {
	ionoscloud.FlowLog
}

type FlowLogProperties struct {
	ionoscloud.FlowLogProperties
}

type FlowLogPut struct {
	ionoscloud.FlowLogPut
}

type FlowLogs struct {
	ionoscloud.FlowLogs
}

type FlowLogsService interface {
	List(datacenterId, serverId, nicId string) (FlowLogs, *Response, error)
	Get(datacenterId, serverId, nicId, flowLogId string) (*FlowLog, *Response, error)
	Create(datacenterId, serverId, nicId string, input FlowLog) (*FlowLog, *Response, error)
	Update(datacenterId, serverId, nicId, flowlogId string, input FlowLogPut) (*FlowLog, *Response, error)
	Delete(datacenterId, serverId, nicId, flowLogId string) (*Response, error)
}

type Group struct {
	ionoscloud.Group
}

type GroupMembers struct {
	ionoscloud.GroupMembers
}

type GroupProperties struct {
	ionoscloud.GroupProperties
}

type GroupShare struct {
	ionoscloud.GroupShare
}

type GroupShareProperties struct {
	ionoscloud.GroupShareProperties
}

type GroupShares struct {
	ionoscloud.GroupShares
}

type Groups struct {
	ionoscloud.Groups
}

type GroupsService interface {
	List() (Groups, *Response, error)
	Get(groupId string) (*Group, *Response, error)
	Create(u Group) (*Group, *Response, error)
	Update(groupId string, input Group) (*Group, *Response, error)
	Delete(groupId string) (*Response, error)
	ListUsers(groupId string) (GroupMembers, *Response, error)
	AddUser(groupId string, input ionoscloud.UserGroupPost) (*User, *Response, error)
	RemoveUser(groupId, userId string) (*Response, error)
	ListShares(groupId string) (GroupShares, *Response, error)
	GetShare(groupId, resourceId string) (*GroupShare, *Response, error)
	AddShare(groupId, resourceId string, input GroupShare) (*GroupShare, *Response, error)
	UpdateShare(groupId, resourceId string, input GroupShare) (*GroupShare, *Response, error)
	RemoveShare(groupId, resourceId string) (*Response, error)
	ListResources(groupId string) (ResourceGroups, *Response, error)
}

type Image struct {
	ionoscloud.Image
}

type ImageFileProperties struct {
	Path       string // File name, server path (not local) and file extension included
	DataBuffer *bufio.Reader
}

type ImageProperties struct {
	ionoscloud.ImageProperties
}

type Images struct {
	ionoscloud.Images
}

type ImagesService interface {
	List() (Images, *Response, error)
	Get(imageId string) (*Image, *Response, error)
	Update(imageId string, imgProp ImageProperties) (*Image, *Response, error)
	Delete(imageId string) (*Response, error)
}

type IpBlock struct {
	ionoscloud.IpBlock
}

type IpBlockProperties struct {
	ionoscloud.IpBlockProperties
}

type IpBlocks struct {
	ionoscloud.IpBlocks
}

type IpBlocksService interface {
	List() (IpBlocks, *Response, error)
	Get(IpBlockId string) (*IpBlock, *Response, error)
	Create(name, location string, size int32) (*IpBlock, *Response, error)
	Update(ipBlockId string, input IpBlockProperties) (*IpBlock, *Response, error)
	Delete(ipBlockId string) (*Response, error)
}

type IpConsumer struct {
	ionoscloud.IpConsumer
}

type IpFailover struct {
	ionoscloud.IPFailover
}

type K8sCluster struct {
	ionoscloud.KubernetesCluster
}

type K8sClusterForPost struct {
	ionoscloud.KubernetesClusterForPost
}

type K8sClusterForPut struct {
	ionoscloud.KubernetesClusterForPut
}

type K8sClusterProperties struct {
	ionoscloud.KubernetesClusterProperties
}

type K8sClusterPropertiesForPost struct {
	ionoscloud.KubernetesClusterPropertiesForPost
}

type K8sClusterPropertiesForPut struct {
	ionoscloud.KubernetesClusterPropertiesForPut
}

type K8sClusters struct {
	ionoscloud.KubernetesClusters
}

type K8sMaintenanceWindow struct {
	ionoscloud.KubernetesMaintenanceWindow
}

type K8sNode struct {
	ionoscloud.KubernetesNode
}

type K8sNodePool struct {
	ionoscloud.KubernetesNodePool
}

type K8sNodePoolForPost struct {
	ionoscloud.KubernetesNodePoolForPost
}

type K8sNodePoolForPut struct {
	ionoscloud.KubernetesNodePoolForPut
}

type K8sNodePoolLan struct {
	ionoscloud.KubernetesNodePoolLan
}

type K8sNodePoolProperties struct {
	ionoscloud.KubernetesNodePoolProperties
}

type K8sNodePoolPropertiesForPost struct {
	ionoscloud.KubernetesNodePoolPropertiesForPost
}

type K8sNodePoolPropertiesForPut struct {
	ionoscloud.KubernetesNodePoolPropertiesForPut
}

type K8sNodePools struct {
	ionoscloud.KubernetesNodePools
}

type K8sNodeProperties struct {
	ionoscloud.KubernetesNodeProperties
}

type K8sNodes struct {
	ionoscloud.KubernetesNodes
}

type K8sService interface {
	ListClusters() (K8sClusters, *Response, error)
	GetCluster(clusterId string) (*K8sCluster, *Response, error)
	// IsPublicCluster(clusterId string) (bool, error)
	CreateCluster(u K8sClusterForPost) (*K8sCluster, *Response, error)
	UpdateCluster(clusterId string, input K8sClusterForPut) (*K8sCluster, *Response, error)
	DeleteCluster(clusterId string) (*Response, error)
	ReadKubeConfig(clusterId string) (string, *Response, error)
	ListNodePools(clusterId string) (K8sNodePools, *Response, error)
	GetNodePool(clusterId, nodepoolId string) (*K8sNodePool, *Response, error)
	CreateNodePool(clusterId string, nodepool K8sNodePoolForPost) (*K8sNodePool, *Response, error)
	UpdateNodePool(clusterId, nodepoolId string, nodepool K8sNodePoolForPut) (*K8sNodePool, *Response, error)
	DeleteNodePool(clusterId, nodepoolId string) (*Response, error)
	DeleteNode(clusterId, nodepoolId, nodeId string) (*Response, error)
	RecreateNode(clusterId, nodepoolId, nodeId string) (*Response, error)
	GetNode(clusterId, nodepoolId, nodeId string) (*K8sNode, *Response, error)
	ListNodes(clusterId, nodepoolId string) (K8sNodes, *Response, error)
	ListVersions() ([]string, *Response, error)
	GetVersion() (string, *Response, error)
}

type Label struct {
	ionoscloud.Label
}

type LabelResource struct {
	ionoscloud.LabelResource
}

type LabelResources struct {
	ionoscloud.LabelResources
}

type LabelResourcesService interface {
	GetByUrn(labelurn string) (*Label, *Response, error)
	List() (Labels, *Response, error)
	DatacenterList(datacenterId string) (LabelResources, *Response, error)
	DatacenterGet(datacenterId, key string) (*LabelResource, *Response, error)
	DatacenterCreate(datacenterId, key, value string) (*LabelResource, *Response, error)
	DatacenterDelete(datacenterId, key string) (*Response, error)
	ServerList(datacenterId, serverId string) (LabelResources, *Response, error)
	ServerGet(datacenterId, serverId, key string) (*LabelResource, *Response, error)
	ServerCreate(datacenterId, serverId, key, value string) (*LabelResource, *Response, error)
	ServerDelete(datacenterId, serverId, key string) (*Response, error)
	VolumeList(datacenterId, serverId string) (LabelResources, *Response, error)
	VolumeGet(datacenterId, serverId, key string) (*LabelResource, *Response, error)
	VolumeCreate(datacenterId, serverId, key, value string) (*LabelResource, *Response, error)
	VolumeDelete(datacenterId, serverId, key string) (*Response, error)
	IpBlockList(ipblockId string) (LabelResources, *Response, error)
	IpBlockGet(ipblockId, key string) (*LabelResource, *Response, error)
	IpBlockCreate(ipblockId, key, value string) (*LabelResource, *Response, error)
	IpBlockDelete(ipblockId, key string) (*Response, error)
	SnapshotList(snapshotId string) (LabelResources, *Response, error)
	SnapshotGet(snapshotId, key string) (*LabelResource, *Response, error)
	SnapshotCreate(snapshotId, key, value string) (*LabelResource, *Response, error)
	SnapshotDelete(snapshotId, key string) (*Response, error)
}

type Labels struct {
	ionoscloud.Labels
}

type Lan struct {
	ionoscloud.Lan
}

type LanNics struct {
	ionoscloud.LanNics
}

type LanPost struct {
	ionoscloud.Lan
}

type LanProperties struct {
	ionoscloud.LanProperties
}

type Lans struct {
	ionoscloud.Lans
}

type LansService interface {
	List(datacenterId string) (Lans, *Response, error)
	Get(datacenterId, lanId string) (*Lan, *Response, error)
	Create(datacenterId string, input LanPost) (*LanPost, *Response, error)
	Update(datacenterId, lanId string, input LanProperties) (*Lan, *Response, error)
	Delete(datacenterId, lanId string) (*Response, error)
}

type ListQueryParams struct {
	Filters     *map[string][]string `json:"Filters,omitempty"`
	OrderBy     *string              `json:"OrderBy,omitempty"`
	QueryParams QueryParams          `json:"QueryParams,omitempty"`
}

type Loadbalancer struct {
	ionoscloud.Loadbalancer
}

type LoadbalancerProperties struct {
	ionoscloud.LoadbalancerProperties
}

type Loadbalancers struct {
	ionoscloud.Loadbalancers
}

type LoadbalancersService interface {
	List(datacenterId string) (Loadbalancers, *Response, error)
	Get(datacenterId, loadbalancerId string) (*Loadbalancer, *Response, error)
	Create(datacenterId, name string, dhcp bool) (*Loadbalancer, *Response, error)
	Update(datacenterId, loadbalancerId string, input LoadbalancerProperties) (*Loadbalancer, *Response, error)
	Delete(datacenterId, loadbalancerId string) (*Response, error)
	AttachNic(datacenterId, loadbalancerId, nicId string) (*Nic, *Response, error)
	ListNics(datacenterId, loadbalancerId string) (BalancedNics, *Response, error)
	GetNic(datacenterId, loadbalancerId, nicId string) (*Nic, *Response, error)
	DetachNic(datacenterId, loadbalancerId, nicId string) (*Response, error)
}

type Location struct {
	ionoscloud.Location
}

type Locations struct {
	ionoscloud.Locations
}

type LocationsService interface {
	List() (Locations, *Response, error)
	GetByRegionAndLocationId(regionId, locationId string) (*Location, *Response, error)
	GetByRegionId(regionId string) (Locations, *Response, error)
}

type NatGateway struct {
	ionoscloud.NatGateway
}

type NatGatewayLanProperties struct {
	ionoscloud.NatGatewayLanProperties
}

type NatGatewayProperties struct {
	ionoscloud.NatGatewayProperties
}

type NatGatewayRule struct {
	ionoscloud.NatGatewayRule
}

type NatGatewayRuleProperties struct {
	ionoscloud.NatGatewayRuleProperties
}

type NatGatewayRules struct {
	ionoscloud.NatGatewayRules
}

type NatGateways struct {
	ionoscloud.NatGateways
}

type NatGatewaysService interface {
	List(datacenterId string) (NatGateways, *Response, error)
	Get(datacenterId, natGatewayId string) (*NatGateway, *Response, error)
	Create(datacenterId string, input NatGateway) (*NatGateway, *Response, error)
	Update(datacenterId, natGatewayId string, input NatGatewayProperties) (*NatGateway, *Response, error)
	Delete(datacenterId, natGatewayId string) (*Response, error)
	ListRules(datacenterId, natGatewayId string) (NatGatewayRules, *Response, error)
	GetRule(datacenterId, natGatewayId, ruleId string) (*NatGatewayRule, *Response, error)
	CreateRule(datacenterId, natGatewayId string, input NatGatewayRule) (*NatGatewayRule, *Response, error)
	UpdateRule(datacenterId, natGatewayId, ruleId string, input NatGatewayRuleProperties) (*NatGatewayRule, *Response, error)
	DeleteRule(datacenterId, natGatewayId, ruleId string) (*Response, error)
	ListFlowLogs(datacenterId, natGatewayId string) (FlowLogs, *Response, error)
	GetFlowLog(datacenterId, natGatewayId, flowlogId string) (*FlowLog, *Response, error)
	CreateFlowLog(datacenterId, natGatewayId string, input FlowLog) (*FlowLog, *Response, error)
	UpdateFlowLog(datacenterId, natGatewayId, flowlogId string, input *FlowLogProperties) (*FlowLog, *Response, error)
	DeleteFlowLog(datacenterId, natGatewayId, flowlogId string) (*Response, error)
}

type NetworkLoadBalancer struct {
	ionoscloud.NetworkLoadBalancer
}

type NetworkLoadBalancerForwardingRule struct {
	ionoscloud.NetworkLoadBalancerForwardingRule
}

type NetworkLoadBalancerForwardingRuleHealthCheck struct {
	ionoscloud.NetworkLoadBalancerForwardingRuleHealthCheck
}

type NetworkLoadBalancerForwardingRuleProperties struct {
	ionoscloud.NetworkLoadBalancerForwardingRuleProperties
}

type NetworkLoadBalancerForwardingRuleTarget struct {
	ionoscloud.NetworkLoadBalancerForwardingRuleTarget
}

type NetworkLoadBalancerForwardingRuleTargetHealthCheck struct {
	ionoscloud.NetworkLoadBalancerForwardingRuleTargetHealthCheck
}

type NetworkLoadBalancerForwardingRules struct {
	ionoscloud.NetworkLoadBalancerForwardingRules
}

type NetworkLoadBalancerProperties struct {
	ionoscloud.NetworkLoadBalancerProperties
}

type NetworkLoadBalancerPut struct {
	ionoscloud.NetworkLoadBalancerPut
}

type NetworkLoadBalancers struct {
	ionoscloud.NetworkLoadBalancers
}

type NetworkLoadBalancersService interface {
	List(datacenterId string) (NetworkLoadBalancers, *Response, error)
	Get(datacenterId, networkLoadBalancerId string) (*NetworkLoadBalancer, *Response, error)
	Create(datacenterId string, input NetworkLoadBalancer) (*NetworkLoadBalancer, *Response, error)
	Update(datacenterId, networkLoadBalancerId string, input NetworkLoadBalancerProperties) (*NetworkLoadBalancer, *Response, error)
	Delete(datacenterId, networkLoadBalancerId string) (*Response, error)
	ListForwardingRules(datacenterId, networkLoadBalancerId string) (NetworkLoadBalancerForwardingRules, *Response, error)
	GetForwardingRule(datacenterId, networkLoadBalancerId, forwardingRuleId string) (*NetworkLoadBalancerForwardingRule, *Response, error)
	CreateForwardingRule(datacenterId, networkLoadBalancerId string, input NetworkLoadBalancerForwardingRule) (*NetworkLoadBalancerForwardingRule, *Response, error)
	UpdateForwardingRule(datacenterId, networkLoadBalancerId, forwardingRuleId string, input *NetworkLoadBalancerForwardingRuleProperties) (*NetworkLoadBalancerForwardingRule, *Response, error)
	DeleteForwardingRule(datacenterId, networkLoadBalancerId, forwardingRuleId string) (*Response, error)
	ListFlowLogs(datacenterId, networkLoadBalancerId string) (FlowLogs, *Response, error)
	GetFlowLog(datacenterId, networkLoadBalancerId, flowLogId string) (*FlowLog, *Response, error)
	CreateFlowLog(datacenterId, networkLoadBalancerId string, input FlowLog) (*FlowLog, *Response, error)
	UpdateFlowLog(datacenterId, networkLoadBalancerId, flowLogId string, input *FlowLogProperties) (*FlowLog, *Response, error)
	DeleteFlowLog(datacenterId, networkLoadBalancerId, flowLogId string) (*Response, error)
}

type Nic struct {
	ionoscloud.Nic
}

type NicProperties struct {
	ionoscloud.NicProperties
}

type Nics struct {
	ionoscloud.Nics
}

type NicsService interface {
	List(datacenterId, serverId string) (Nics, *Response, error)
	Get(datacenterId, serverId, nicId string) (*Nic, *Response, error)
	Create(datacenterId, serverId string, input Nic) (*Nic, *Response, error)
	Update(datacenterId, serverId, nicId string, input NicProperties) (*Nic, *Response, error)
	Delete(datacenterId, serverId, nicId string) (*Response, error)
}

type PccsService interface {
	List() (PrivateCrossConnects, *Response, error)
	Get(pccId string) (*PrivateCrossConnect, *Response, error)
	GetPeers(pccId string) (*[]Peer, *Response, error)
	Create(u PrivateCrossConnect) (*PrivateCrossConnect, *Response, error)
	Update(pccId string, input PrivateCrossConnectProperties) (*PrivateCrossConnect, *Response, error)
	Delete(pccId string) (*Response, error)
}

type Peer struct {
	ionoscloud.Peer
}

type PrivateCrossConnect struct {
	ionoscloud.PrivateCrossConnect
}

type PrivateCrossConnectProperties struct {
	ionoscloud.PrivateCrossConnectProperties
}

type PrivateCrossConnects struct {
	ionoscloud.PrivateCrossConnects
}

type QueryParams struct {
	Depth  *int32 `json:"Depth,omitempty"`
	Pretty *bool  `json:"Pretty,omitempty"`
}

type RemoteConsoleUrl struct {
	ionoscloud.RemoteConsoleUrl
}

type Request struct {
	ionoscloud.Request
}

type RequestStatus struct {
	ionoscloud.RequestStatus
}

type Requests struct {
	ionoscloud.Requests
}

type RequestsService interface {
	List() (Requests, *Response, error)
	Get(requestId string) (*Request, *Response, error)
	GetStatus(requestId string) (*RequestStatus, *Response, error)
	Wait(requestId string) (*Response, error)
}

type Resource struct {
	ionoscloud.Resource
}

type ResourceGroups struct {
	ionoscloud.ResourceGroups
}

type Resources struct {
	ionoscloud.Resources
}

type Response struct {
	ionoscloud.APIResponse
}

type S3Key struct {
	ionoscloud.S3Key
}

type S3Keys struct {
	ionoscloud.S3Keys
}

type S3KeysService interface {
	List(userId string) (S3Keys, *Response, error)
	Get(userId, keyId string) (*S3Key, *Response, error)
	Create(userId string) (*S3Key, *Response, error)
	Update(userId, keyId string, key S3Key) (*S3Key, *Response, error)
	Delete(userId, keyId string) (*Response, error)
}

type Server struct {
	ionoscloud.Server
}

type ServerProperties struct {
	ionoscloud.ServerProperties
}

type Servers struct {
	ionoscloud.Servers
}

type ServersService interface {
	List(datacenterId string) (Servers, *Response, error)
	Get(datacenterId, serverId string) (*Server, *Response, error)
	Create(datacenterId string, input Server) (*Server, *Response, error)
	Update(datacenterId, serverId string, input ServerProperties) (*Server, *Response, error)
	Delete(datacenterId, serverId string) (*Response, error)
	Start(datacenterId, serverId string) (*Response, error)
	Stop(datacenterId, serverId string) (*Response, error)
	Reboot(datacenterId, serverId string) (*Response, error)
	Suspend(datacenterId, serverId string) (*Response, error)
	Resume(datacenterId, serverId string) (*Response, error)
	GetToken(datacenterId, serverId string) (Token, *Response, error)
	GetRemoteConsoleUrl(datacenterId, serverId string) (RemoteConsoleUrl, *Response, error)
	AttachVolume(datacenterId, serverId, volumeId string) (*Volume, *Response, error)
	DetachVolume(datacenterId, serverId, volumeId string) (*Response, error)
	ListVolumes(datacenterId, serverId string) (AttachedVolumes, *Response, error)
	GetVolume(datacenterId, serverId, volumeId string) (*Volume, *Response, error)
	ListCdroms(datacenterId, serverId string) (Cdroms, *Response, error)
	AttachCdrom(datacenterId, serverId, cdromId string) (*Image, *Response, error)
	GetCdrom(datacenterId, serverId, cdromId string) (*Image, *Response, error)
	DetachCdrom(datacenterId, serverId, cdromId string) (*Response, error)
}

type Snapshot struct {
	ionoscloud.Snapshot
}

type SnapshotProperties struct {
	ionoscloud.SnapshotProperties
}

type Snapshots struct {
	ionoscloud.Snapshots
}

type SnapshotsService interface {
	List() (Snapshots, *Response, error)
	Get(snapshotId string) (*Snapshot, *Response, error)
	Create(datacenterId, volumeId, name, description, licenceType string, secAuthProtection bool) (*Snapshot, *Response, error)
	Update(snapshotId string, snapshotProp SnapshotProperties) (*Snapshot, *Response, error)
	Restore(datacenterId, volumeId, snapshotId string) (*Response, error)
	Delete(snapshotId string) (*Response, error)
}

type TargetGroup struct {
	ionoscloud.TargetGroup
}

type TargetGroupHealthCheck struct {
	ionoscloud.TargetGroupHealthCheck
}

type TargetGroupHttpHealthCheck struct {
	ionoscloud.TargetGroupHttpHealthCheck
}

type TargetGroupProperties struct {
	ionoscloud.TargetGroupProperties
}

type TargetGroupTarget struct {
	ionoscloud.TargetGroupTarget
}

type TargetGroups struct {
	ionoscloud.TargetGroups
}

type TargetGroupsService interface {
	List() (TargetGroups, *Response, error)
	Get(targetGroupId string) (*TargetGroup, *Response, error)
	Create(tg TargetGroup) (*TargetGroup, *Response, error)
	Update(targetGroupId string, input *TargetGroupProperties) (*TargetGroup, *Response, error)
	Delete(targetGroupId string) (*Response, error)
}

type Template struct {
	ionoscloud.Template
}

type TemplateProperties struct {
	ionoscloud.TemplateProperties
}

type Templates struct {
	ionoscloud.Templates
}

type TemplatesService interface {
	List() (Templates, *Response, error)
	Get(templateId string) (*Template, *Response, error)
}

type Token struct {
	ionoscloud.Token
}

type UploadProperties struct {
	ImageFileProperties
	FTPServerProperties
}

type User struct {
	ionoscloud.User
}

type UserPost struct {
	ionoscloud.UserPost
}

type UserProperties struct {
	ionoscloud.UserProperties
}

type UserPropertiesPost struct {
	ionoscloud.UserPropertiesPost
}

type UserPropertiesPut struct {
	ionoscloud.UserPropertiesPut
}

type UserPut struct {
	ionoscloud.UserPut
}

type Users struct {
	ionoscloud.Users
}

type UsersService interface {
	List() (Users, *Response, error)
	Get(userId string) (*User, *Response, error)
	Create(u UserPost) (*User, *Response, error)
	Update(userId string, input UserPut) (*User, *Response, error)
	Delete(userId string) (*Response, error)
	ListResources() (Resources, *Response, error)
	GetResourcesByType(resourceType string) (Resources, *Response, error)
	GetResourceByTypeAndId(resourceType, resourceId string) (*Resource, *Response, error)
}

type Volume struct {
	ionoscloud.Volume
}

type VolumeProperties struct {
	ionoscloud.VolumeProperties
}

type Volumes struct {
	ionoscloud.Volumes
}

type VolumesService interface {
	List(datacenterId string) (Volumes, *Response, error)
	Get(datacenterId, volumeId string) (*Volume, *Response, error)
	Create(datacenterId string, input Volume) (*Volume, *Response, error)
	Update(datacenterId, volumeId string, input VolumeProperties) (*Volume, *Response, error)
	Delete(datacenterId, volumeId string) (*Response, error)
}