cloud

type AccessRule struct {
	// Access Rule ID
	ID string `json:"id,required" format:"uuid4"`
	// Access mode
	//
	// Any of "ro", "rw".
	AccessLevel AccessRuleAccessLevel `json:"access_level,required"`
	// Source IP or network
	AccessTo string `json:"access_to,required" format:"ipvanyaddress"`
	// Access Rule state
	//
	// Any of "active", "applying", "denying", "error", "new", "queued_to_apply",
	// "queued_to_deny".
	State AccessRuleState `json:"state,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID          respjson.Field
		AccessLevel respjson.Field
		AccessTo    respjson.Field
		State       respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type AccessRuleAccessLevel string

type AccessRuleList struct {
	// Number of objects
	Count int64 `json:"count,required"`
	// Objects
	Results []AccessRule `json:"results,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Count       respjson.Field
		Results     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type AccessRuleState string

type AllowedAddressPairs struct {
	// Subnet mask or IP address of the port specified in allowed_address_pairs
	IPAddress string `json:"ip_address,required" format:"ipvanyaddress"`
	// MAC address of the port specified in allowed_address_pairs
	MacAddress string `json:"mac_address,nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		IPAddress   respjson.Field
		MacAddress  respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type AwsIamData struct {
	// AWS IAM key ID.
	AwsAccessKeyID string `json:"aws_access_key_id,required"`
	// AWS IAM secret key.
	AwsSecretAccessKey string `json:"aws_secret_access_key,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		AwsAccessKeyID     respjson.Field
		AwsSecretAccessKey respjson.Field
		ExtraFields        map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type AwsIamDataParam struct {
	// AWS IAM key ID.
	AwsAccessKeyID string `json:"aws_access_key_id,required"`
	// AWS IAM secret key.
	AwsSecretAccessKey string `json:"aws_secret_access_key,required"`
	// contains filtered or unexported fields
}

type BaremetalFixedAddress struct {
	// Address
	Addr string `json:"addr,required"`
	// Interface name. This field will be `null` if `with_interfaces_name=true` is not
	// set in the request when listing servers. It will also be `null` if the
	// `interface_name` was not specified during server creation or when attaching the
	// interface.
	InterfaceName string `json:"interface_name,required"`
	// The unique identifier of the subnet associated with this address.
	SubnetID string `json:"subnet_id,required"`
	// The name of the subnet associated with this address.
	SubnetName string `json:"subnet_name,required"`
	// Type of the address
	Type constant.Fixed `json:"type,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Addr          respjson.Field
		InterfaceName respjson.Field
		SubnetID      respjson.Field
		SubnetName    respjson.Field
		Type          respjson.Field
		ExtraFields   map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BaremetalFlavor struct {
	// Flavor architecture type
	Architecture string `json:"architecture,required"`
	// Disabled flavor flag
	Disabled bool `json:"disabled,required"`
	// Flavor ID is the same as name
	FlavorID string `json:"flavor_id,required"`
	// Flavor name
	FlavorName string `json:"flavor_name,required"`
	// Flavor operating system
	OsType string `json:"os_type,required"`
	// RAM size in MiB
	Ram int64 `json:"ram,required"`
	// Flavor resource class for mapping to hardware capacity
	ResourceClass string `json:"resource_class,required"`
	// Virtual CPU count. For bare metal flavors, it's a physical CPU count
	Vcpus int64 `json:"vcpus,required"`
	// Number of available instances of given configuration
	Capacity int64 `json:"capacity,nullable"`
	// Currency code. Shown if the include_prices query parameter if set to true
	CurrencyCode string `json:"currency_code,nullable"`
	// Additional hardware description
	HardwareDescription map[string]string `json:"hardware_description"`
	// Price per hour. Shown if the include_prices query parameter if set to true
	PricePerHour float64 `json:"price_per_hour,nullable"`
	// Price per month. Shown if the include_prices query parameter if set to true
	PricePerMonth float64 `json:"price_per_month,nullable"`
	// Price status for the UI
	//
	// Any of "error", "hide", "show".
	PriceStatus BaremetalFlavorPriceStatus `json:"price_status,nullable"`
	// Count of reserved but not used nodes. If a client don't have reservations for
	// the flavor, it's None.
	ReservedInStock int64 `json:"reserved_in_stock,nullable"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Architecture        respjson.Field
		Disabled            respjson.Field
		FlavorID            respjson.Field
		FlavorName          respjson.Field
		OsType              respjson.Field
		Ram                 respjson.Field
		ResourceClass       respjson.Field
		Vcpus               respjson.Field
		Capacity            respjson.Field
		CurrencyCode        respjson.Field
		HardwareDescription respjson.Field
		PricePerHour        respjson.Field
		PricePerMonth       respjson.Field
		PriceStatus         respjson.Field
		ReservedInStock     respjson.Field
		ExtraFields         map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BaremetalFlavorList struct {
	// Number of objects
	Count int64 `json:"count,required"`
	// Objects
	Results []BaremetalFlavor `json:"results,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Count       respjson.Field
		Results     respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BaremetalFlavorListParams struct {
	ProjectID param.Opt[int64] `path:"project_id,omitzero,required" json:"-"`
	RegionID  param.Opt[int64] `path:"region_id,omitzero,required" json:"-"`
	// Flag for filtering disabled flavors in the region. Defaults to true
	Disabled param.Opt[bool] `query:"disabled,omitzero" json:"-"`
	// Set to true to exclude flavors dedicated to linux images. Default False
	ExcludeLinux param.Opt[bool] `query:"exclude_linux,omitzero" json:"-"`
	// Set to true to exclude flavors dedicated to windows images. Default False
	ExcludeWindows param.Opt[bool] `query:"exclude_windows,omitzero" json:"-"`
	// Set to true if the response should include flavor capacity
	IncludeCapacity param.Opt[bool] `query:"include_capacity,omitzero" json:"-"`
	// Set to true if the response should include flavor prices
	IncludePrices param.Opt[bool] `query:"include_prices,omitzero" json:"-"`
	// Optional. Set to true if flavor listing should include count of reserved
	// resources in stock.
	IncludeReservationStock param.Opt[bool] `query:"include_reservation_stock,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type BaremetalFlavorListSuitableParams struct {
	ProjectID param.Opt[int64] `path:"project_id,omitzero,required" json:"-"`
	RegionID  param.Opt[int64] `path:"region_id,omitzero,required" json:"-"`
	// Set to true if flavor listing should include flavor prices
	IncludePrices param.Opt[bool] `query:"include_prices,omitzero" json:"-"`
	// Apptemplate ID
	ApptemplateID param.Opt[string] `json:"apptemplate_id,omitzero"`
	// Image ID
	ImageID param.Opt[string] `json:"image_id,omitzero"`
	// contains filtered or unexported fields
}

type BaremetalFlavorPriceStatus string

type BaremetalFlavorService struct {
	Options []option.RequestOption
}

type BaremetalFloatingAddress struct {
	// Address
	Addr string `json:"addr,required"`
	// Type of the address
	Type constant.Floating `json:"type,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Addr        respjson.Field
		Type        respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BaremetalImageListParams struct {
	ProjectID param.Opt[int64] `path:"project_id,omitzero,required" json:"-"`
	RegionID  param.Opt[int64] `path:"region_id,omitzero,required" json:"-"`
	// Show price
	IncludePrices param.Opt[bool] `query:"include_prices,omitzero" json:"-"`
	// Any value to show private images
	Private param.Opt[string] `query:"private,omitzero" json:"-"`
	// Filter by tag key-value pairs. Must be a valid JSON string. 'curl -G
	// --data-urlencode 'tag_key_value={"key": "value"}' --url
	// 'http://localhost:1111/v1/images/1/1'"
	TagKeyValue param.Opt[string] `query:"tag_key_value,omitzero" json:"-"`
	// Filter by tag keys.
	TagKey []string `query:"tag_key,omitzero" json:"-"`
	// Image visibility. Globally visible images are public
	//
	// Any of "private", "public", "shared".
	Visibility BaremetalImageListParamsVisibility `query:"visibility,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type BaremetalImageListParamsVisibility string

type BaremetalImageService struct {
	Options []option.RequestOption
}

type BaremetalServer struct {
	// Bare metal server ID
	ID string `json:"id,required" format:"uuid4"`
	// Map of network_name to list of addresses in that network
	Addresses map[string][]BaremetalServerAddressUnion `json:"addresses,required"`
	// IP addresses of the instances that are blackholed by DDoS mitigation system
	BlackholePorts []BlackholePort `json:"blackhole_ports,required"`
	// Datetime when bare metal server was created
	CreatedAt time.Time `json:"created_at,required" format:"date-time"`
	// Task that created this entity
	CreatorTaskID string `json:"creator_task_id,required"`
	// Bare metal advanced DDoS protection profile. It is always `null` if query
	// parameter `with_ddos=true` is not set.
	DDOSProfile DDOSProfile `json:"ddos_profile,required"`
	// Fixed IP assigned to instance
	FixedIPAssignments []BaremetalServerFixedIPAssignment `json:"fixed_ip_assignments,required"`
	// Flavor details
	Flavor BaremetalServerFlavor `json:"flavor,required"`
	// Instance isolation information
	InstanceIsolation InstanceIsolation `json:"instance_isolation,required"`
	// Bare metal server name
	Name string `json:"name,required"`
	// Project ID
	ProjectID int64 `json:"project_id,required"`
	// Region name
	Region string `json:"region,required"`
	// Region ID
	RegionID int64 `json:"region_id,required"`
	// SSH key assigned to bare metal server
	SSHKeyName string `json:"ssh_key_name,required"`
	// Bare metal server status
	//
	// Any of "ACTIVE", "BUILD", "DELETED", "ERROR", "HARD_REBOOT", "MIGRATING",
	// "PASSWORD", "PAUSED", "REBOOT", "REBUILD", "RESCUE", "RESIZE", "REVERT_RESIZE",
	// "SHELVED", "SHELVED_OFFLOADED", "SHUTOFF", "SOFT_DELETED", "SUSPENDED",
	// "UNKNOWN", "VERIFY_RESIZE".
	Status BaremetalServerStatus `json:"status,required"`
	// List of key-value tags associated with the resource. A tag is a key-value pair
	// that can be associated with a resource, enabling efficient filtering and
	// grouping for better organization and management. Some tags are read-only and
	// cannot be modified by the user. Tags are also integrated with cost reports,
	// allowing cost data to be filtered based on tag keys or values.
	Tags []Tag `json:"tags,required"`
	// The UUID of the active task that currently holds a lock on the resource. This
	// lock prevents concurrent modifications to ensure consistency. If `null`, the
	// resource is not locked.
	TaskID string `json:"task_id,required"`
	// Task state
	TaskState string `json:"task_state,required"`
	// Bare metal server state
	//
	// Any of "active", "building", "deleted", "error", "paused", "rescued", "resized",
	// "shelved", "shelved_offloaded", "soft-deleted", "stopped", "suspended".
	VmState BaremetalServerVmState `json:"vm_state,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                 respjson.Field
		Addresses          respjson.Field
		BlackholePorts     respjson.Field
		CreatedAt          respjson.Field
		CreatorTaskID      respjson.Field
		DDOSProfile        respjson.Field
		FixedIPAssignments respjson.Field
		Flavor             respjson.Field
		InstanceIsolation  respjson.Field
		Name               respjson.Field
		ProjectID          respjson.Field
		Region             respjson.Field
		RegionID           respjson.Field
		SSHKeyName         respjson.Field
		Status             respjson.Field
		Tags               respjson.Field
		TaskID             respjson.Field
		TaskState          respjson.Field
		VmState            respjson.Field
		ExtraFields        map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BaremetalServerAddressUnion struct {
	Addr string `json:"addr"`
	Type string `json:"type"`
	// This field is from variant [BaremetalFixedAddress].
	InterfaceName string `json:"interface_name"`
	// This field is from variant [BaremetalFixedAddress].
	SubnetID string `json:"subnet_id"`
	// This field is from variant [BaremetalFixedAddress].
	SubnetName string `json:"subnet_name"`
	JSON       struct {
		Addr          respjson.Field
		Type          respjson.Field
		InterfaceName respjson.Field
		SubnetID      respjson.Field
		SubnetName    respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BaremetalServerFixedIPAssignment struct {
	// Is network external
	External bool `json:"external,required"`
	// Ip address
	IPAddress string `json:"ip_address,required"`
	// Interface subnet id
	SubnetID string `json:"subnet_id,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		External    respjson.Field
		IPAddress   respjson.Field
		SubnetID    respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BaremetalServerFlavor struct {
	// CPU architecture
	Architecture string `json:"architecture,required"`
	// Flavor ID is the same as name
	FlavorID string `json:"flavor_id,required"`
	// Flavor name
	FlavorName string `json:"flavor_name,required"`
	// Additional hardware description
	HardwareDescription BaremetalServerFlavorHardwareDescription `json:"hardware_description,required"`
	// Operating system
	OsType string `json:"os_type,required"`
	// RAM size in MiB
	Ram int64 `json:"ram,required"`
	// Flavor resource class for mapping to hardware capacity
	ResourceClass string `json:"resource_class,required"`
	// Virtual CPU count. For bare metal flavors, it's a physical CPU count
	Vcpus int64 `json:"vcpus,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		Architecture        respjson.Field
		FlavorID            respjson.Field
		FlavorName          respjson.Field
		HardwareDescription respjson.Field
		OsType              respjson.Field
		Ram                 respjson.Field
		ResourceClass       respjson.Field
		Vcpus               respjson.Field
		ExtraFields         map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BaremetalServerFlavorHardwareDescription struct {
	// Human-readable CPU description
	CPU string `json:"cpu,required"`
	// Human-readable disk description
	Disk string `json:"disk,required"`
	// If the flavor is licensed, this field contains the license type
	License string `json:"license,required"`
	// Human-readable NIC description
	Network string `json:"network,required"`
	// Human-readable RAM description
	Ram string `json:"ram,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CPU         respjson.Field
		Disk        respjson.Field
		License     respjson.Field
		Network     respjson.Field
		Ram         respjson.Field
		ExtraFields map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BaremetalServerListParams struct {
	// Project ID
	ProjectID param.Opt[int64] `path:"project_id,omitzero,required" json:"-"`
	// Region ID
	RegionID param.Opt[int64] `path:"region_id,omitzero,required" json:"-"`
	// Filters the instances by a date and time stamp when the instances last changed.
	ChangesBefore param.Opt[time.Time] `query:"changes-before,omitzero" format:"date-time" json:"-"`
	// Filters the instances by a date and time stamp when the instances last changed
	// status.
	ChangesSince param.Opt[time.Time] `query:"changes-since,omitzero" format:"date-time" json:"-"`
	// Filter out instances by flavor_id. Flavor id must match exactly.
	FlavorID param.Opt[string] `query:"flavor_id,omitzero" json:"-"`
	// Filter out instances by flavor_prefix.
	FlavorPrefix param.Opt[string] `query:"flavor_prefix,omitzero" json:"-"`
	// Include managed k8s worker nodes
	IncludeK8s param.Opt[bool] `query:"include_k8s,omitzero" json:"-"`
	// An IPv4 address to filter results by. Note: partial matches are allowed. For
	// example, searching for 192.168.0.1 will return 192.168.0.1, 192.168.0.10,
	// 192.168.0.110, and so on.
	IP param.Opt[string] `query:"ip,omitzero" json:"-"`
	// Optional. Limit the number of returned items
	Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
	// Filter instances by name. You can provide a full or partial name, instances with
	// matching names will be returned. For example, entering 'test' will return all
	// instances that contain 'test' in their name.
	Name param.Opt[string] `query:"name,omitzero" json:"-"`
	// Optional. Offset value is used to exclude the first set of records from the
	// result
	Offset param.Opt[int64] `query:"offset,omitzero" json:"-"`
	// Include only isolated instances
	OnlyIsolated param.Opt[bool] `query:"only_isolated,omitzero" json:"-"`
	// Return bare metals only with external fixed IP addresses.
	OnlyWithFixedExternalIP param.Opt[bool] `query:"only_with_fixed_external_ip,omitzero" json:"-"`
	// Filter result by ddos protection profile name. Effective only with with_ddos set
	// to true.
	ProfileName param.Opt[string] `query:"profile_name,omitzero" json:"-"`
	// Optional. Filter by tag key-value pairs. curl -G --data-urlencode
	// "tag_key_value={"key": "value"}" --url
	// "https://example.com/cloud/v1/resource/1/1"
	TagKeyValue param.Opt[string] `query:"tag_key_value,omitzero" json:"-"`
	// Filter the server list result by the UUID of the server. Allowed UUID part
	Uuid param.Opt[string] `query:"uuid,omitzero" json:"-"`
	// Include DDoS profile information for bare-metal servers in the response when set
	// to `true`. Otherwise, the `ddos_profile` field in the response is `null` by
	// default.
	WithDDOS param.Opt[bool] `query:"with_ddos,omitzero" json:"-"`
	// Include `interface_name` in the addresses
	WithInterfacesName param.Opt[bool] `query:"with_interfaces_name,omitzero" json:"-"`
	// Order by field and direction.
	//
	// Any of "created.asc", "created.desc", "name.asc", "name.desc", "status.asc",
	// "status.desc".
	OrderBy BaremetalServerListParamsOrderBy `query:"order_by,omitzero" json:"-"`
	// Filter result by DDoS protection_status. Effective only with with_ddos set to
	// true. (Active, Queued or Error)
	//
	// Any of "Active", "Queued", "Error".
	ProtectionStatus BaremetalServerListParamsProtectionStatus `query:"protection_status,omitzero" json:"-"`
	// Filters instances by a server status, as a string.
	//
	// Any of "ACTIVE", "BUILD", "ERROR", "HARD_REBOOT", "REBOOT", "REBUILD", "RESCUE",
	// "SHUTOFF", "SUSPENDED".
	Status BaremetalServerListParamsStatus `query:"status,omitzero" json:"-"`
	// Optional. Filter by tag values. ?tag_value=value1&tag_value=value2
	TagValue []string `query:"tag_value,omitzero" json:"-"`
	// Return bare metals either only with advanced or only basic DDoS protection.
	// Effective only with with_ddos set to true. (advanced or basic)
	//
	// Any of "basic", "advanced".
	TypeDDOSProfile BaremetalServerListParamsTypeDDOSProfile `query:"type_ddos_profile,omitzero" json:"-"`
	// contains filtered or unexported fields
}

type BaremetalServerListParamsOrderBy string

type BaremetalServerListParamsProtectionStatus string

type BaremetalServerListParamsStatus string

type BaremetalServerListParamsTypeDDOSProfile string

type BaremetalServerNewParams struct {
	// Project ID
	ProjectID param.Opt[int64] `path:"project_id,omitzero,required" json:"-"`
	// Region ID
	RegionID param.Opt[int64] `path:"region_id,omitzero,required" json:"-"`
	// The flavor of the instance.
	Flavor string `json:"flavor,required"`
	// A list of network interfaces for the server. You can create one or more
	// interfaces - private, public, or both.
	Interfaces []BaremetalServerNewParamsInterfaceUnion `json:"interfaces,omitzero,required"`
	// Specifies the name of the SSH keypair, created via the
	// <a href="#operation/SSHKeyCollectionViewSet.post">/v1/ssh_keys endpoint</a>.
	SSHKeyName param.Opt[string] `json:"ssh_key_name,omitzero"`
	// Apptemplate ID. Either `image_id` or `apptemplate_id` is required.
	ApptemplateID param.Opt[string] `json:"apptemplate_id,omitzero"`
	// Image ID. Either `image_id` or `apptemplate_id` is required.
	ImageID param.Opt[string] `json:"image_id,omitzero" format:"uuid4"`
	// Server name.
	Name param.Opt[string] `json:"name,omitzero"`
	// If you want server names to be automatically generated based on IP addresses,
	// you can provide a name template instead of specifying the name manually. The
	// template should include a placeholder that will be replaced during provisioning.
	// Supported placeholders are: `{ip_octets}` (last 3 octets of the IP),
	// `{two_ip_octets}`, and `{one_ip_octet}`.
	NameTemplate param.Opt[string] `json:"name_template,omitzero"`
	// For Linux instances, 'username' and 'password' are used to create a new user.
	// When only 'password' is provided, it is set as the password for the default user
	// of the image. For Windows instances, 'username' cannot be specified. Use the
	// 'password' field to set the password for the 'Admin' user on Windows. Use the
	// 'user_data' field to provide a script to create new users on Windows. The
	// password of the Admin user cannot be updated via 'user_data'.
	Password param.Opt[string] `json:"password,omitzero"`
	// String in base64 format. For Linux instances, 'user_data' is ignored when
	// 'password' field is provided. For Windows instances, Admin user password is set
	// by 'password' field and cannot be updated via 'user_data'. Examples of the
	// user_data: https://cloudinit.readthedocs.io/en/latest/topics/examples.html
	UserData param.Opt[string] `json:"user_data,omitzero"`
	// For Linux instances, 'username' and 'password' are used to create a new user.
	// For Windows instances, 'username' cannot be specified. Use 'password' field to
	// set the password for the 'Admin' user on Windows.
	Username param.Opt[string] `json:"username,omitzero"`
	// Parameters for the application template if creating the instance from an
	// `apptemplate`.
	AppConfig any `json:"app_config,omitzero"`
	// Enable advanced DDoS protection for the server
	DDOSProfile BaremetalServerNewParamsDDOSProfile `json:"ddos_profile,omitzero"`
	// Key-value tags to associate with the resource. A tag is a key-value pair that
	// can be associated with a resource, enabling efficient filtering and grouping for
	// better organization and management. Some tags are read-only and cannot be
	// modified by the user. Tags are also integrated with cost reports, allowing cost
	// data to be filtered based on tag keys or values.
	Tags TagUpdateMap `json:"tags,omitzero"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsDDOSProfile struct {
	// DDoS profile template ID
	ProfileTemplate int64 `json:"profile_template,required"`
	// DDoS profile template name
	ProfileTemplateName param.Opt[string] `json:"profile_template_name,omitzero"`
	// DDoS profile parameters
	Fields []BaremetalServerNewParamsDDOSProfileField `json:"fields,omitzero"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsDDOSProfileField struct {
	// ID of DDoS profile field
	BaseField param.Opt[int64] `json:"base_field,omitzero"`
	// Name of DDoS profile field
	FieldName param.Opt[string] `json:"field_name,omitzero"`
	// Basic type value. Only one of 'value' or 'field_value' must be specified.
	Value param.Opt[string] `json:"value,omitzero"`
	// Complex value. Only one of 'value' or 'field_value' must be specified.
	FieldValue BaremetalServerNewParamsDDOSProfileFieldFieldValueUnion `json:"field_value,omitzero"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsDDOSProfileFieldFieldValueUnion struct {
	OfAnyArray []any             `json:",omitzero,inline"`
	OfInt      param.Opt[int64]  `json:",omitzero,inline"`
	OfString   param.Opt[string] `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceAnySubnet struct {
	// The network where the instance will be connected.
	NetworkID string `json:"network_id,required" format:"uuid4"`
	// Interface name. Defaults to `null` and is returned as `null` in the API response
	// if not set.
	InterfaceName param.Opt[string] `json:"interface_name,omitzero"`
	// You can specify a specific IP address from your subnet.
	IPAddress param.Opt[string] `json:"ip_address,omitzero" format:"ipvanyaddress"`
	// Specifies the trunk group to which this interface belongs. Applicable only for
	// bare metal servers. Each unique port group is mapped to a separate trunk port.
	// Use this to control how interfaces are grouped across trunks.
	PortGroup param.Opt[int64] `json:"port_group,omitzero"`
	// Allows the instance to have a public IP that can be reached from the internet.
	FloatingIP BaremetalServerNewParamsInterfaceAnySubnetFloatingIPUnion `json:"floating_ip,omitzero"`
	// Specify `ipv4`, `ipv6`, or `dual` to enable both.
	//
	// Any of "dual", "ipv4", "ipv6".
	IPFamily InterfaceIPFamily `json:"ip_family,omitzero"`
	// Instance will be attached to a subnet with the largest count of free IPs.
	//
	// This field can be elided, and will marshal its zero value as "any_subnet".
	Type constant.AnySubnet `json:"type,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceAnySubnetFloatingIPExisting struct {
	// An existing available floating IP id must be specified if the source is set to
	// `existing`
	ExistingFloatingID string `json:"existing_floating_id,required" format:"uuid4"`
	// An existing available floating IP will be attached to the instance. A floating
	// IP is a public IP that makes the instance accessible from the internet, even if
	// it only has a private IP. It works like SNAT, allowing outgoing and incoming
	// traffic.
	//
	// This field can be elided, and will marshal its zero value as "existing".
	Source constant.Existing `json:"source,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceAnySubnetFloatingIPNew struct {
	// A new floating IP will be created and attached to the instance. A floating IP is
	// a public IP that makes the instance accessible from the internet, even if it
	// only has a private IP. It works like SNAT, allowing outgoing and incoming
	// traffic.
	Source constant.New `json:"source,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceAnySubnetFloatingIPUnion struct {
	OfNew      *BaremetalServerNewParamsInterfaceAnySubnetFloatingIPNew      `json:",omitzero,inline"`
	OfExisting *BaremetalServerNewParamsInterfaceAnySubnetFloatingIPExisting `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceExternal struct {
	// Interface name. Defaults to `null` and is returned as `null` in the API response
	// if not set.
	InterfaceName param.Opt[string] `json:"interface_name,omitzero"`
	// Specifies the trunk group to which this interface belongs. Applicable only for
	// bare metal servers. Each unique port group is mapped to a separate trunk port.
	// Use this to control how interfaces are grouped across trunks.
	PortGroup param.Opt[int64] `json:"port_group,omitzero"`
	// Specify `ipv4`, `ipv6`, or `dual` to enable both.
	//
	// Any of "dual", "ipv4", "ipv6".
	IPFamily InterfaceIPFamily `json:"ip_family,omitzero"`
	// A public IP address will be assigned to the instance.
	//
	// This field can be elided, and will marshal its zero value as "external".
	Type constant.External `json:"type,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceReservedFixedIP struct {
	// Network ID the subnet belongs to. Port will be plugged in this network.
	PortID string `json:"port_id,required"`
	// Interface name. Defaults to `null` and is returned as `null` in the API response
	// if not set.
	InterfaceName param.Opt[string] `json:"interface_name,omitzero"`
	// Specifies the trunk group to which this interface belongs. Applicable only for
	// bare metal servers. Each unique port group is mapped to a separate trunk port.
	// Use this to control how interfaces are grouped across trunks.
	PortGroup param.Opt[int64] `json:"port_group,omitzero"`
	// Allows the instance to have a public IP that can be reached from the internet.
	FloatingIP BaremetalServerNewParamsInterfaceReservedFixedIPFloatingIPUnion `json:"floating_ip,omitzero"`
	// An existing available reserved fixed IP will be attached to the instance. If the
	// reserved IP is not public and you choose to add a floating IP, the instance will
	// be accessible from the internet.
	//
	// This field can be elided, and will marshal its zero value as
	// "reserved_fixed_ip".
	Type constant.ReservedFixedIP `json:"type,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceReservedFixedIPFloatingIPExisting struct {
	// An existing available floating IP id must be specified if the source is set to
	// `existing`
	ExistingFloatingID string `json:"existing_floating_id,required" format:"uuid4"`
	// An existing available floating IP will be attached to the instance. A floating
	// IP is a public IP that makes the instance accessible from the internet, even if
	// it only has a private IP. It works like SNAT, allowing outgoing and incoming
	// traffic.
	//
	// This field can be elided, and will marshal its zero value as "existing".
	Source constant.Existing `json:"source,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceReservedFixedIPFloatingIPNew struct {
	// A new floating IP will be created and attached to the instance. A floating IP is
	// a public IP that makes the instance accessible from the internet, even if it
	// only has a private IP. It works like SNAT, allowing outgoing and incoming
	// traffic.
	Source constant.New `json:"source,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceReservedFixedIPFloatingIPUnion struct {
	OfNew      *BaremetalServerNewParamsInterfaceReservedFixedIPFloatingIPNew      `json:",omitzero,inline"`
	OfExisting *BaremetalServerNewParamsInterfaceReservedFixedIPFloatingIPExisting `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceSubnet struct {
	// The network where the instance will be connected.
	NetworkID string `json:"network_id,required" format:"uuid4"`
	// The instance will get an IP address from this subnet.
	SubnetID string `json:"subnet_id,required" format:"uuid4"`
	// Interface name. Defaults to `null` and is returned as `null` in the API response
	// if not set.
	InterfaceName param.Opt[string] `json:"interface_name,omitzero"`
	// Specifies the trunk group to which this interface belongs. Applicable only for
	// bare metal servers. Each unique port group is mapped to a separate trunk port.
	// Use this to control how interfaces are grouped across trunks.
	PortGroup param.Opt[int64] `json:"port_group,omitzero"`
	// Allows the instance to have a public IP that can be reached from the internet.
	FloatingIP BaremetalServerNewParamsInterfaceSubnetFloatingIPUnion `json:"floating_ip,omitzero"`
	// The instance will get an IP address from the selected network. If you choose to
	// add a floating IP, the instance will be reachable from the internet. Otherwise,
	// it will only have a private IP within the network.
	//
	// This field can be elided, and will marshal its zero value as "subnet".
	Type constant.Subnet `json:"type,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceSubnetFloatingIPExisting struct {
	// An existing available floating IP id must be specified if the source is set to
	// `existing`
	ExistingFloatingID string `json:"existing_floating_id,required" format:"uuid4"`
	// An existing available floating IP will be attached to the instance. A floating
	// IP is a public IP that makes the instance accessible from the internet, even if
	// it only has a private IP. It works like SNAT, allowing outgoing and incoming
	// traffic.
	//
	// This field can be elided, and will marshal its zero value as "existing".
	Source constant.Existing `json:"source,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceSubnetFloatingIPNew struct {
	// A new floating IP will be created and attached to the instance. A floating IP is
	// a public IP that makes the instance accessible from the internet, even if it
	// only has a private IP. It works like SNAT, allowing outgoing and incoming
	// traffic.
	Source constant.New `json:"source,required"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceSubnetFloatingIPUnion struct {
	OfNew      *BaremetalServerNewParamsInterfaceSubnetFloatingIPNew      `json:",omitzero,inline"`
	OfExisting *BaremetalServerNewParamsInterfaceSubnetFloatingIPExisting `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

type BaremetalServerNewParamsInterfaceUnion struct {
	OfExternal        *BaremetalServerNewParamsInterfaceExternal        `json:",omitzero,inline"`
	OfSubnet          *BaremetalServerNewParamsInterfaceSubnet          `json:",omitzero,inline"`
	OfAnySubnet       *BaremetalServerNewParamsInterfaceAnySubnet       `json:",omitzero,inline"`
	OfReservedFixedIP *BaremetalServerNewParamsInterfaceReservedFixedIP `json:",omitzero,inline"`
	// contains filtered or unexported fields
}

type BaremetalServerRebuildParams struct {
	ProjectID param.Opt[int64] `path:"project_id,omitzero,required" json:"-"`
	RegionID  param.Opt[int64] `path:"region_id,omitzero,required" json:"-"`
	// Image ID
	ImageID param.Opt[string] `json:"image_id,omitzero"`
	// String in base64 format. Must not be passed together with 'username' or
	// 'password'. Examples of the user_data:
	// https://cloudinit.readthedocs.io/en/latest/topics/examples.html
	UserData param.Opt[string] `json:"user_data,omitzero"`
	// contains filtered or unexported fields
}

type BaremetalServerService struct {
	Options []option.RequestOption
}

type BaremetalServerStatus string

type BaremetalServerVmState string

type BaremetalService struct {
	Options []option.RequestOption
	Images  BaremetalImageService
	Flavors BaremetalFlavorService
	Servers BaremetalServerService
}

type BillingReservation struct {
	// Reservation id
	ID int64 `json:"id,required"`
	// Reservation active from date
	ActiveFrom time.Time `json:"active_from,required" format:"date"`
	// Reservation active to date
	ActiveTo time.Time `json:"active_to,required" format:"date"`
	// Name of the billing period, e.g month
	ActivityPeriod string `json:"activity_period,required"`
	// Length of the full reservation period by `activity_period`
	ActivityPeriodLength int64 `json:"activity_period_length,required"`
	// Reservation amount prices
	AmountPrices BillingReservationAmountPrices `json:"amount_prices,required"`
	// Billing plan id
	BillingPlanID int64 `json:"billing_plan_id,required"`
	// Reservation creation date
	CreatedAt time.Time `json:"created_at,required" format:"date-time"`
	// Error message if any occured during reservation
	Error string `json:"error,required"`
	// ETA delivery if bare metal out of stock. Value None means that bare metal in
	// stock.
	Eta time.Time `json:"eta,required" format:"date"`
	// Hide or show expiration message to customer.
	IsExpirationMessageVisible bool `json:"is_expiration_message_visible,required"`
	// Reservation name
	Name string `json:"name,required"`
	// List of possible next reservation statuses
	NextStatuses []string `json:"next_statuses,required"`
	// Region id
	RegionID int64 `json:"region_id,required"`
	// Region name
	RegionName string `json:"region_name,required"`
	// The date when show expiration date to customer
	RemindExpirationMessage time.Time `json:"remind_expiration_message,required" format:"date"`
	// List of reservation resources
	Resources []BillingReservationResource `json:"resources,required"`
	// Reservation status
	Status string `json:"status,required"`
	// User status
	UserStatus string `json:"user_status,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		ID                         respjson.Field
		ActiveFrom                 respjson.Field
		ActiveTo                   respjson.Field
		ActivityPeriod             respjson.Field
		ActivityPeriodLength       respjson.Field
		AmountPrices               respjson.Field
		BillingPlanID              respjson.Field
		CreatedAt                  respjson.Field
		Error                      respjson.Field
		Eta                        respjson.Field
		IsExpirationMessageVisible respjson.Field
		Name                       respjson.Field
		NextStatuses               respjson.Field
		RegionID                   respjson.Field
		RegionName                 respjson.Field
		RemindExpirationMessage    respjson.Field
		Resources                  respjson.Field
		Status                     respjson.Field
		UserStatus                 respjson.Field
		ExtraFields                map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BillingReservationAmountPrices struct {
	// Commit price of the item charged per month
	CommitPricePerMonth string `json:"commit_price_per_month,required"`
	// Commit price of the item charged per hour
	CommitPricePerUnit string `json:"commit_price_per_unit,required"`
	// Commit price of the item charged for all period reservation
	CommitPriceTotal string `json:"commit_price_total,required"`
	// Currency code (3 letter code per ISO 4217)
	CurrencyCode string `json:"currency_code,required"`
	// Overcommit price of the item charged per month
	OvercommitPricePerMonth string `json:"overcommit_price_per_month,required"`
	// Overcommit price of the item charged per hour
	OvercommitPricePerUnit string `json:"overcommit_price_per_unit,required"`
	// Overcommit price of the item charged for all period reservation
	OvercommitPriceTotal string `json:"overcommit_price_total,required"`
	// JSON contains metadata for fields, check presence with [respjson.Field.Valid].
	JSON struct {
		CommitPricePerMonth     respjson.Field
		CommitPricePerUnit      respjson.Field
		CommitPriceTotal        respjson.Field
		CurrencyCode            respjson.Field
		OvercommitPricePerMonth respjson.Field
		OvercommitPricePerUnit  respjson.Field
		OvercommitPriceTotal    respjson.Field
		ExtraFields             map[string]respjson.Field
		// contains filtered or unexported fields
	} `json:"-"`
}

type BillingReservationListParams struct {
	// Lower bound, starting from what date the reservation was/will be activated
	ActivatedFrom param.Opt[time.Time] `query:"activated_from,omitzero" format:"date" json:"-"`
	// High bound, before what date the reservation was/will be activated
	ActivatedTo param.Opt[time.Time] `query:"activated_to,omitzero" format:"date" json:"-"`
	// Lower bound the filter, showing result(s) equal to or greater than date the
	// reservation was created
	CreatedFrom param.Opt[time.Time] `query:"created_from,omitzero" format:"date-time" json:"-"`
	// High bound the filter, showing result(s) equal to or less date the reservation
	// was created
	CreatedTo param.Opt[time.Time] `query:"created_to,omitzero" format:"date-time" json:"-"`
	// Lower bound, starting from what date the reservation was/will be deactivated
	DeactivatedFrom param.Opt[time.Time] `query:"deactivated_from,omitzero" format:"date" json:"-"`
	// High bound, before what date the reservation was/will be deactivated
	DeactivatedTo param.Opt[time.Time] `query:"deactivated_to,omitzero" format:"date" json:"-"`
	// Limit of reservation list page
	Limit param.Opt[int64] `query:"limit,omitzero" json:"-"`
	// Name from billing features for specific resource
	MetricName param.Opt[string] `query:"metric_name,omitzero" json:"-"`
	// Offset in reservation list
	Offset param.Opt[int64] `query:"offset,omitzero" json:"-"`
	// Region for reservation
	RegionID param.Opt[int64] `query:"region_id,omitzero" json:"-"`
	// Field for fixed a status by reservation workflow
	//
	// Any of "ACTIVATED", "APPROVED", "COPIED", "CREATED", "EXPIRED", "REJECTED",
	// "RESERVED", "WAITING_FOR_PAYMENT".
	Status []string `query:"status,omitzero" json:"-"`
	// contains filtered or unexported fields
}