common

type DhcpConfiguration []configDeclaration

type DiskAndCDConfigData struct {
	SCSI_Present         string
	SCSI_diskAdapterType string
	SATA_Present         string
	NVME_Present         string

	DiskType                   string
	CDROMType                  string
	CDROMType_PrimarySecondary string
	CDROM_PATH                 string
}

type DiskConfig struct {
	// The size(s) of additional virtual hard disks in MB. If not specified,
	// the virtual machine will contain only a primary hard disk.
	AdditionalDiskSize []uint `mapstructure:"disk_additional_size" required:"false"`
	// The adapter type for additional virtual disk(s). Available options
	//  are `ide`, `sata`, `nvme`, or `scsi`.
	//
	// ~> **Note:** When specifying `scsi` as the adapter type, the default
	// adapter type is set to `lsilogic`. If another option is specified, the
	// plugin will assume it is a `scsi` interface of that specified type.
	//
	// ~> **Note:** This option is intended for advanced users.
	DiskAdapterType string `mapstructure:"disk_adapter_type" required:"false"`
	// The filename for the virtual disk to create _without_ the `.vmdk`
	// extension. Defaults to `disk`.
	DiskName string `mapstructure:"vmdk_name" required:"false"`
	// The type of virtual disk to create.
	//
	//   For local desktop hypervisors, the available options are:
	//
	//   Type ID | Description
	//   ------- | ---
	//   `0`     | Growable virtual disk contained in a single file (monolithic sparse).
	//   `1`     | Growable virtual disk split into 2GB files (split sparse).
	//   `2`     | Preallocated virtual disk contained in a single file (monolithic flat).
	//   `3`     | Preallocated virtual disk split into 2GB files (split flat).
	//   `4`     | Preallocated virtual disk compatible with ESXi (VMFS flat).
	//   `5`     | Compressed disk optimized for streaming.
	//
	//   Defaults to `1`.
	//
	//   For remote hypervisors, the available options are: `zeroedthick`,
	//   `eagerzeroedthick`, and `thin`. Defaults to `zeroedthick`.
	//
	//   ~> **Note:** The `rdm:dev`, `rdmp:dev`, and `2gbsparse` types are not
	//   supported for remote hypervisors.
	//
	//   ~> **Note:** Set `skip_compaction` to `true` when using `zeroedthick`
	//   or `eagerzeroedthick` due to default disk compaction behavior.
	//
	// ~> **Note:** This option is intended for advanced users.
	DiskTypeId string `mapstructure:"disk_type_id" required:"false"`
}

type Driver interface {
	// Clone clones the VMX and the disk to the destination path. The
	// destination is a path to the VMX file. The disk will be copied
	// to that same directory.
	Clone(dst string, src string, cloneType bool, snapshot string) error

	// CompactDisk compacts a virtual disk.
	CompactDisk(string) error

	// CreateDisk creates a virtual disk with the given size.
	CreateDisk(string, string, string, string) error

	// CreateSnapshot creates a snapshot of the supplied .vmx file with
	// the given name
	CreateSnapshot(string, string) error

	// Checks if the VMX file at the given path is running.
	IsRunning(string) (bool, error)

	// Start starts a VM specified by the path to the VMX given.
	Start(string, bool) error

	// Stop stops a VM specified by the path to the VMX given.
	Stop(string) error

	// SuppressMessages modifies the VMX or surrounding directory so that
	// VMware doesn't show any annoying messages.
	SuppressMessages(string) error

	// Get the path to the VMware ISO for the given flavor.
	ToolsIsoPath(string) string

	// Attach the VMware tools ISO
	ToolsInstall() error

	// Verify checks to make sure that this driver should function
	// properly. This should check that all the files it will use
	// appear to exist and so on. If everything is okay, this doesn't
	// return an error. Otherwise, this returns an error. Each vmware
	// driver should assign the VmwareMachine callback functions for locating
	// paths within this function.
	Verify() error

	/// This is to establish a connection to the guest
	CommHost(multistep.StateBag) (string, error)

	/// These methods are generally implemented by the VmwareDriver
	/// structure within this file. A driver implementation can
	/// reimplement these, though, if it wants.
	GetVmwareDriver() VmwareDriver

	// Get the guest hw address for the vm
	GuestAddress(multistep.StateBag) (string, error)

	// Get the guest ip address for the vm
	PotentialGuestIP(multistep.StateBag) ([]string, error)

	// Get the host hw address for the vm
	HostAddress(multistep.StateBag) (string, error)

	// Get the host ip address for the vm
	HostIP(multistep.StateBag) (string, error)

	// Export the vm to ovf or ova format using ovftool
	Export([]string) error

	// OvfTool
	VerifyOvfTool(bool, bool) error
}

type DriverConfig struct {
	// Path to "VMware Fusion.app". By default this is
	// /Applications/VMware Fusion.app but this setting allows you to
	// customize this.
	FusionAppPath string `mapstructure:"fusion_app_path" required:"false"`
	// The type of remote machine that will be used to
	// build this VM rather than a local desktop product. The only value accepted
	// for this currently is esx5. If this is not set, a desktop product will
	// be used. By default, this is not set.
	RemoteType string `mapstructure:"remote_type" required:"false"`
	// The path to the datastore where the VM will be stored
	// on the ESXi machine.
	RemoteDatastore string `mapstructure:"remote_datastore" required:"false"`
	// The path to the datastore where supporting files
	// will be stored during the build on the remote machine.
	RemoteCacheDatastore string `mapstructure:"remote_cache_datastore" required:"false"`
	// The path where the ISO and/or floppy files will
	// be stored during the build on the remote machine. The path is relative to
	// the remote_cache_datastore on the remote machine.
	RemoteCacheDirectory string `mapstructure:"remote_cache_directory" required:"false"`
	// When set to true, Packer will cleanup the cache folder where the ISO file is stored during the build on the remote machine.
	// By default, this is set to false.
	CleanUpRemoteCache bool `mapstructure:"cleanup_remote_cache" required:"false"`
	// The host of the remote machine used for access.
	// This is only required if remote_type is enabled.
	RemoteHost string `mapstructure:"remote_host" required:"false"`
	// The SSH port of the remote machine
	RemotePort int `mapstructure:"remote_port" required:"false"`
	// The SSH username used to access the remote machine.
	RemoteUser string `mapstructure:"remote_username" required:"false"`
	// The SSH password for access to the remote machine.
	RemotePassword string `mapstructure:"remote_password" required:"false"`
	// The SSH key for access to the remote machine.
	RemotePrivateKey string `mapstructure:"remote_private_key_file" required:"false"`
	// When Packer is preparing to run a
	// remote hypervisor build, and export is not disable, by default it runs a no-op
	// ovftool command to make sure that the remote_username and remote_password
	// given are valid. If you set this flag to true, Packer will skip this
	// validation. Default: false.
	SkipValidateCredentials bool `mapstructure:"skip_validate_credentials" required:"false"`
}

type DriverMock struct {
	sync.Mutex

	CloneCalled bool
	CloneDst    string
	CloneSrc    string
	Linked      bool
	Snapshot    string
	CloneErr    error

	CompactDiskCalled bool
	CompactDiskPath   string
	CompactDiskErr    error

	CreateDiskCalled      bool
	CreateDiskOutput      string
	CreateDiskSize        string
	CreateDiskAdapterType string
	CreateDiskTypeId      string
	CreateDiskErr         error

	CreateSnapshotCalled  bool
	CreateSnapshotVMXPath string
	CreateSnapshotName    string
	CreateSnapshotErr     error

	ExportCalled bool
	ExportArgs   []string

	IsRunningCalled bool
	IsRunningPath   string
	IsRunningResult bool
	IsRunningErr    error

	CommHostCalled bool
	CommHostState  multistep.StateBag
	CommHostResult string
	CommHostErr    error

	HostAddressCalled bool
	HostAddressState  multistep.StateBag
	HostAddressResult string
	HostAddressErr    error

	HostIPCalled bool
	HostIPState  multistep.StateBag
	HostIPResult string
	HostIPErr    error

	GuestAddressCalled bool
	GuestAddressState  multistep.StateBag
	GuestAddressResult string
	GuestAddressErr    error

	PotentialGuestIPCalled bool
	PotentialGuestIPState  multistep.StateBag
	PotentialGuestIPResult []string
	PotentialGuestIPErr    error

	StartCalled   bool
	StartPath     string
	StartHeadless bool
	StartErr      error

	StopCalled bool
	StopPath   string
	StopErr    error

	SuppressMessagesCalled bool
	SuppressMessagesPath   string
	SuppressMessagesErr    error

	ToolsIsoPathCalled bool
	ToolsIsoPathFlavor string
	ToolsIsoPathResult string

	ToolsInstallCalled bool
	ToolsInstallErr    error

	DhcpLeasesPathCalled bool
	DhcpLeasesPathDevice string
	DhcpLeasesPathResult string

	DhcpConfPathCalled bool
	DhcpConfPathResult string

	VmnetnatConfPathCalled bool
	VmnetnatConfPathResult string

	NetmapConfPathCalled bool
	NetmapConfPathResult string

	VerifyCalled bool
	VerifyErr    error

	VerifyOvftoolCalled bool
}

type ESX5Driver struct {
	Host           string
	Port           int
	Username       string
	Password       string
	PrivateKeyFile string
	Datastore      string
	CacheDatastore string
	CacheDirectory string
	VMName         string
	CommConfig     communicator.Config
	// contains filtered or unexported fields
}

type ExportConfig struct {
	// The output format of the exported virtual machine. Allowed values are
	// `ova`, `ovf`, or `vmx`. Defaults to `vmx` for local desktop hypervisors
	// and `ova` for remote hypervisors.
	//
	// For builds on a remote hypervisor, `remote_password` must be set when
	// exporting the virtual machine
	//
	// For builds on a local desktop hypervisor, the plugin will create a `.vmx`
	// and export the virtual machine as an `.ovf` or `.ova` file. THe plugin
	// will not delete the `.vmx` and `.vmdk` files. You must manually delete
	// these files if they are no longer needed.
	//
	// ~> **Note:** Ensure VMware OVF Tool is installed. For the latest version,
	// visit [VMware OVF Tool](https://developer.broadcom.com/tools/open-virtualization-format-ovf-tool/latest).
	//
	// ~> **Note:** For local builds, the plugin will create a `.vmx` and
	// supporting files in the output directory and will then export the
	// virtual machine to the specified format. These files are **not**
	// automatically cleaned up after the export process.
	Format string `mapstructure:"format" required:"false"`
	// Additional command-line arguments to send to VMware OVF Tool during the
	// export process. Each string in the array represents a separate
	// command-line argument.
	//
	// ~> **Important:** The options `--noSSLVerify`, `--skipManifestCheck`, and
	// `--targetType` are automatically applied by the plugin for remote exports
	// and should not be included in the options. For local OVF/OVA exports,
	// the plugin does not preset any VMware OVF Tool options by default.
	//
	// ~> **Note:** Ensure VMware OVF Tool is installed. For the latest version,
	// visit [VMware OVF Tool](https://developer.broadcom.com/tools/open-virtualization-format-ovf-tool/latest).
	OVFToolOptions []string `mapstructure:"ovftool_options" required:"false"`
	// Skips the export of the virtual machine. This is useful if the build
	// output is not the resultant image, but created inside the virtual
	// machine. This is useful for debugging purposes. Defaults to `false`.
	SkipExport bool `mapstructure:"skip_export" required:"false"`
	// Determines whether a virtual machine built on a remote hypervisor should
	// remain registered after the build process. Setting this to `true` can be
	// useful if the virtual machine does not need to be exported. Defaults to
	// `false`.
	KeepRegistered bool `mapstructure:"keep_registered" required:"false"`
	// At the end of the build process, the plugin defragments and compacts the
	// disks using `vmware-vdiskmanager` or `vmkfstools` for ESXi environments.
	// In some cases, this process may result in slightly larger disk sizes.
	// If this occurs, you can opt to skip the disk compaction step by using
	// this setting. Defaults to `false`. Defaults to `true` for ESXi when
	// `disk_type_id` is not explicitly defined and `false`
	SkipCompaction bool `mapstructure:"skip_compaction" required:"false"`
}

type Fusion5Driver struct {
	VmwareDriver

	// This is the path to the "VMware Fusion.app"
	AppPath string

	// SSHConfig are the SSH settings for the Fusion VM
	SSHConfig *SSHConfig
}

type Fusion6Driver struct {
	Fusion5Driver
}

type HWConfig struct {
	// The firmware type for the virtual machine.
	// Allowed values are `bios`, `efi`, and `efi-secure` (for secure boot).
	// Defaults to the recommended firmware type for the guest operating system.
	Firmware string `mapstructure:"firmware" required:"false"`
	// The number of virtual CPUs cores for the virtual machine.
	CpuCount int `mapstructure:"cpus" required:"false"`
	// The number of virtual CPU cores per socket for the virtual machine.
	CoreCount int `mapstructure:"cores" required:"false"`
	// The amount of memory for the virtual machine in MB.
	MemorySize int `mapstructure:"memory" required:"false"`
	// The network which the virtual machine will connect for local desktop
	// hypervisors. Use the generic values that map to a device, such as
	// `hostonly`, `nat`, or `bridged`. Defaults to `nat`.
	//
	// ~> **Note:** If not set to one of these generic values, then it is
	// assumed to be a network device (_e.g._, `VMnet0..x`).
	Network string `mapstructure:"network" required:"false"`
	// The network which the virtual machine will connect on a remote
	// hypervisor.
	NetworkName string `mapstructure:"network_name" required:"false"`
	// The virtual machine network card type. Recommended values are `e1000` and
	// `vmxnet3`. Defaults to `e1000`.
	//
	// Refer to VMware product documentation for supported network adapter types
	// for the hypervisor and guest operating system.
	NetworkAdapterType string `mapstructure:"network_adapter_type" required:"false"`
	// Enable virtual sound card device. Defaults to `false`.
	Sound bool `mapstructure:"sound" required:"false"`
	// Enable a the USB 2.0 controllers for the virtual machine.
	// Defaults to `false`.
	//
	// ~> **Note:** To enable USB 3.0 controllers, set a `usb_xhci.present`
	// key to `true` in the `vmx_data` option.
	USB bool `mapstructure:"usb" required:"false"`
	// Add a serial port to the virtual machine. Use a format of
	// `Type:option1,option2,...`. Allowed values for the field `Type` include:
	// `FILE`, `DEVICE`, `PIPE`, `AUTO`, or `NONE`.
	//
	// * `FILE:path(,yield)` - Specifies the path to the local file to be used
	//   as the serial port.
	//
	//   * `yield` (bool) - This is an optional boolean that specifies
	//     whether the virtual machine should yield the CPU when polling the
	//     port. By default, the builder will assume this as `FALSE`.
	//
	// * `DEVICE:path(,yield)` - Specifies the path to the local device to be
	//   used as the serial port. If `path` is empty, then default to the first
	//   serial port.
	//
	//   * `yield` (bool) - This is an optional boolean that specifies
	//     whether the virtual machine should yield the CPU when polling the
	//     port. By default, the builder will assume this as `FALSE`.
	//
	// * `PIPE:path,endpoint,host(,yield)` - Specifies to use the named-pipe
	//   "path" as a serial port. This has a few options that determine how the
	//   VM should use the named-pipe.
	//
	//   * `endpoint` (string) - Chooses the type of the VM-end, which can be
	//     either a `client` or `server`.
	//
	//   * `host` (string) - Chooses the type of the host-end, which can be
	//     either `app` (application) or `vm` (another virtual-machine).
	//
	//   * `yield` (bool) - This is an optional boolean that specifies whether
	//     the virtual machine should yield the CPU when polling the port. By
	//     default, the builder will assume this as `FALSE`.
	//
	// * `AUTO:(yield)` - Specifies to use auto-detection to determine the
	//   serial port to use. This has one option to determine how the virtual
	//   machine should support the serial port.
	//
	//   * `yield` (bool) - This is an optional boolean that specifies whether
	//     the virtual machine should yield the CPU when polling the port. By
	//     default, the builder will assume this as `FALSE`.
	//
	// * `NONE` - Specifies to not use a serial port. (default)
	Serial string `mapstructure:"serial" required:"false"`
	// Add a parallel port to add to the virtual machine. Use a format of
	// `Type:option1,option2,...`. Allowed values for the field `Type` include:
	// `FILE`, `DEVICE`, `AUTO`, or `NONE`.
	//
	// * `FILE:path` - Specifies the path to the local file to be used for the
	//    parallel port.
	//
	// * `DEVICE:path` - Specifies the path to the local device to be used for
	//    the parallel port.
	//
	// * `AUTO:direction` - Specifies to use auto-detection to determine the
	//   parallel port. Direction can be `BI` to specify bidirectional
	//   communication or `UNI` to specify unidirectional communication.
	//
	// * `NONE` - Specifies to not use a parallel port. (default)
	Parallel string `mapstructure:"parallel" required:"false"`
}

type IfconfigIPFinder struct {
	Device string
}

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

type NetmapConfig struct {
	Index  int
	Name   string
	Device string
}

type NetworkMap []map[string]string

type NetworkMapperMock struct {
	NameIntoDeviceCalled int
	DeviceIntoNameCalled int
}

type NetworkNameMapper interface {
	NameIntoDevices(string) ([]string, error)
	DeviceIntoName(string) (string, error)
}

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

type NetworkingType int

type OutputConfig struct {
	// This is the path on your local machine (the one running Packer) to the
	// directory where the resulting virtual machine will be created.
	// This may be relative or absolute. If relative, the path is relative to
	// the working directory when packer is executed.
	//
	// If you are running a remote hypervisor build, the output_dir is the path on your
	// local machine (the machine running Packer) to which Packer will export
	// the vm if you have `"skip_export": false`. If you want to manage the
	// virtual machine's path on the remote datastore, use `remote_output_dir`.
	//
	// This directory must not exist or be empty prior to running
	// the builder.
	//
	// By default this is output-BUILDNAME where "BUILDNAME" is the name of the
	// build.
	OutputDir string `mapstructure:"output_directory" required:"false"`
	// This is the directory on your remote hypervisor where you will save your
	// vm, relative to your remote_datastore.
	//
	// This option's default value is your `vm_name`, and the final path of your
	// vm will be vmfs/volumes/$remote_datastore/$vm_name/$vm_name.vmx where
	// `$remote_datastore` and `$vm_name` match their corresponding template
	// options
	//
	// For example, setting `"remote_output_directory": "path/to/subdir`
	// will create a directory `/vmfs/volumes/remote_datastore/path/to/subdir`.
	//
	// Packer will not create the remote datastore for you; it must already
	// exist. However, Packer will create all directories defined in the option
	// that do not currently exist.
	//
	// This option will be ignored unless you are building on a remote hypervisor.
	RemoteOutputDir string `mapstructure:"remote_output_directory" required:"false"`
}

type OutputDir interface {
	DirExists() (bool, error)
	ListFiles() ([]string, error)
	MkdirAll() error
	Remove(string) error
	RemoveAll() error
	SetOutputDir(string)
	String() string
}

type ParallelPortAuto struct {
	Bidirectional string
}

type ParallelPortDevice struct {
	Bidirectional string
	Devicename    string
}

type ParallelPortFile struct {
	Filename string
}

type ParallelUnion struct {
	Union  interface{}
	File   *ParallelPortFile
	Device *ParallelPortDevice
	Auto   *ParallelPortAuto
}

type Player5Driver struct {
	VmwareDriver

	AppPath          string
	VdiskManagerPath string
	QemuImgPath      string
	VmrunPath        string

	// SSHConfig are the SSH settings for the Fusion VM
	SSHConfig *SSHConfig
}

type Player6Driver struct {
	Player5Driver
}

type RemoteDriver interface {
	Driver

	// UploadISO uploads a local ISO to the remote side and returns the
	// new path that should be used in the VMX along with an error if it
	// exists.
	UploadISO(path string, checksum string, ui packersdk.Ui) (string, error)

	// RemoveCache deletes localPath from the remote cache.
	RemoveCache(localPath string) error

	// Adds a VM to inventory specified by the path to the VMX given.
	Register(path string) error

	// Removes a VM from inventory specified by the path to the VMX given.
	Unregister(path string) error

	// Destroys a VM
	Destroy() error

	// Checks if the VM is destroyed.
	IsDestroyed() (bool, error)

	// Download a remote file to a local file.
	Download(src, dst string) error

	// Reload VM on remote side.
	ReloadVM() error
	// contains filtered or unexported methods
}

type RemoteDriverMock struct {
	DriverMock

	UploadISOCalled bool
	UploadISOPath   string
	UploadISOResult string
	UploadISOErr    error

	RegisterCalled bool
	RegisterPath   string
	RegisterErr    error

	UnregisterCalled bool
	UnregisterPath   string
	UnregisterErr    error

	DestroyCalled bool
	DestroyErr    error

	IsDestroyedCalled bool
	IsDestroyedResult bool
	IsDestroyedErr    error

	UploadErr   error
	DownloadErr error

	RemovedCachePath string
	CacheRemoved     bool

	ReturnValDirExists bool

	ReloadVMErr error
	// contains filtered or unexported fields
}

type RunConfig struct {
	// The plugin defaults to building virtual machines by launching the
	// desktop hypervisor's graphical user interface (GUI) to display the
	// console of the virtual machine being built. When this value is set to
	// `true`, the virtual machine will start without a console; however, the
	// plugin will output VNC connection information in case you need to connect
	// to the console to debug the build process. Defaults to `false`.
	//
	// ~> **Note:** Some users have experienced issues where Packer cannot
	// properly connect to a virtual machine when using `headless`. This is
	// often attributed to the use of an evaluation license for VMware desktop
	// hypervisors. It is recommended to launch the product and accept the
	// evaluation license to resolve this if you encounter an issue with this
	// option.
	Headless bool `mapstructure:"headless" required:"false"`
	// The IP address to use for VNC access to the virtual machine. Defaults to
	// `127.0.0.1`.
	//
	// ~> **Note:** To bind to all interfaces use `0.0.0.0`.
	VNCBindAddress string `mapstructure:"vnc_bind_address" required:"false"`
	// The minimum port number to use for VNC access to the virtual machine.
	// The plugin uses VNC to type the `boot_command`. Defaults to `5900`.
	VNCPortMin int `mapstructure:"vnc_port_min" required:"false"`
	// The maximum port number to use for VNC access to the virtual machine.
	// The plugin uses VNC to type the `boot_command`. Defaults to `6000`.
	//
	// ~> **Note:** The plugin randomly selects port within the inclusive range
	// specified by `vnc_port_min` and `vnc_port_max`.
	VNCPortMax int `mapstructure:"vnc_port_max"`
	// Disables the auto-generation of a VNC password that is used to secure the
	// VNC communication with the virtual machine. Defaults to `false`.
	//
	// ~> **Important:** Must be set to `true` for remote hypervisor builds with
	// VNC enabled.
	VNCDisablePassword bool `mapstructure:"vnc_disable_password" required:"false"`
	// Connect to VNC over a websocket connection. Defaults to `false`.
	//
	// ~> **Note:** When set to `true`, any other VNC configuration options will
	// be ignored.
	//
	// ~> **Important:** Must be set to `true` for remote hypervisor builds with
	// VNC enabled.
	VNCOverWebsocket bool `mapstructure:"vnc_over_websocket" required:"false"`
	// Do not validate TLS certificate when connecting to VNC over a websocket
	// connection. Defaults to `false`.
	InsecureConnection bool `mapstructure:"insecure_connection" required:"false"`
}

type SSHConfig struct {
	Comm communicator.Config `mapstructure:",squash"`

	// TODO: Deprecated. Remove in next major release
	SSHSkipRequestPty bool `mapstructure:"ssh_skip_request_pty"`
}

type SerialConfigAuto struct {
	Devicename string
	Yield      string
}

type SerialConfigDevice struct {
	Devicename string
	Yield      string
}

type SerialConfigFile struct {
	Filename string
	Yield    string
}

type SerialConfigPipe struct {
	Filename string
	Endpoint string
	Host     string
	Yield    string
}

type SerialUnion struct {
	Union  interface{}
	Pipe   *SerialConfigPipe
	File   *SerialConfigFile
	Device *SerialConfigDevice
	Auto   *SerialConfigAuto
}

type StepCleanFiles struct{}

type StepCleanVMX struct {
	RemoveEthernetInterfaces bool
	VNCEnabled               bool
}

type StepCompactDisk struct {
	Skip bool
}

type StepConfigureVMX struct {
	CustomData       map[string]string
	DisplayName      string
	SkipDevices      bool
	VMName           string
	DiskAdapterType  string
	CDROMAdapterType string
}

type StepConfigureVNC struct {
	Enabled            bool
	VNCBindAddress     string
	VNCPortMin         int
	VNCPortMax         int
	VNCDisablePassword bool
	// contains filtered or unexported fields
}

type StepCreateDisks struct {
	OutputDir          *string
	CreateMainDisk     bool
	DiskName           string
	MainDiskSize       uint
	AdditionalDiskSize []uint
	DiskAdapterType    string
	DiskTypeId         string
}

type StepCreateSnapshot struct {
	SnapshotName *string
}

type StepExport struct {
	Format         string
	SkipExport     bool
	VMName         string
	OVFToolOptions []string
	OutputDir      *string
}

type StepHTTPIPDiscover struct{}

type StepOutputDir struct {
	Force bool

	OutputConfig *OutputConfig
	VMName       string

	RemoteType string
	// contains filtered or unexported fields
}

type StepPrepareTools struct {
	RemoteType        string
	ToolsUploadFlavor string
	ToolsSourcePath   string
}

type StepRegister struct {
	Format         string
	KeepRegistered bool
	SkipExport     bool
	// contains filtered or unexported fields
}

type StepRemoteUpload struct {
	Key       string
	Message   string
	DoCleanup bool
	Checksum  string
}

type StepRun struct {
	DurationBeforeStop time.Duration
	Headless           bool
	// contains filtered or unexported fields
}

type StepShutdown struct {
	Command string
	Timeout time.Duration

	// Set this to true if we're testing
	Testing bool
}

type StepSuppressMessages struct{}

type StepUploadTools struct {
	RemoteType        string
	ToolsUploadFlavor string
	ToolsUploadPath   string
	Ctx               interpolate.Context
}

type StepUploadVMX struct {
	RemoteType string
}

type StepVNCBootCommand struct {
	Config bootcommand.VNCConfig
	VMName string
	Ctx    interpolate.Context
	Comm   *communicator.Config
}

type StepVNCConnect struct {
	VNCEnabled         bool
	VNCOverWebsocket   bool
	InsecureConnection bool
	DriverConfig       *DriverConfig
}

type ToolsConfig struct {
	// The flavor of VMware tools to upload into the virtual machine based on
	// the guest operating system. Allowed values are `darwin` (macOS), `linux`,
	// and `windows`. Default is empty and no version will be uploaded.
	ToolsUploadFlavor string `mapstructure:"tools_upload_flavor" required:"false"`
	// The path in the virtual machine to upload the VMware Tools. This only
	// takes effect if `tools_upload_flavor` is non-empty. This is a
	// [configuration template](/packer/docs/templates/legacy_json_templates/engine)
	// that has a single valid variable, `Flavor`, which will be the value of
	// `tools_upload_flavor` when the upload path is set to `{{.Flavor}}.iso`.
	//
	// ~> **Note:** This setting is not used when `remote_type` is `esx5`.
	ToolsUploadPath string `mapstructure:"tools_upload_path" required:"false"`
	// The local path on your machine to the VMware Tools ISO file.
	//
	// ~> **Note:** If not set, but the `tools_upload_flavor` is set, the plugin
	// will load the VMware Tools from the product installation directory.
	ToolsSourcePath string `mapstructure:"tools_source_path" required:"false"`
}

type VMXConfig struct {
	// Key-value pairs that will be inserted into the virtual machine `.vmx`
	// file **before** the virtual machine is started. This is useful for
	// setting advanced properties that are not supported by the plugin.
	//
	// ~> **Note**: This option is intended for advanced users who understand
	// the ramifications of making changes to the `.vmx` file. This option is
	// not necessary for most users.
	VMXData map[string]string `mapstructure:"vmx_data" required:"false"`
	// Key-value pairs that will be inserted into the virtual machine `.vmx`
	// file **after** the virtual machine is started. This is useful for setting
	// advanced properties that are not supported by the plugin.
	//
	// ~> **Note**: This option is intended for advanced users who understand
	// the ramifications of making changes to the `.vmx` file. This option is
	// not necessary for most users.
	VMXDataPost map[string]string `mapstructure:"vmx_data_post" required:"false"`
	// Remove all network adapters from virtual machine `.vmx` file after the
	// virtual machine build is complete. Defaults to `false`.
	//
	// ~> **Note**: This option is useful when building Vagrant boxes since
	// Vagrant will create interfaces when provisioning a box.
	VMXRemoveEthernet bool `mapstructure:"vmx_remove_ethernet_interfaces" required:"false"`
	// The inventory display name for the virtual machine. If set, the value
	// provided will override any value set in the `vmx_data` option or in the
	// `.vmx` file. This option is useful if you are chaining builds and want to
	// ensure that the display name of each step in the chain is unique.
	VMXDisplayName string `mapstructure:"display_name" required:"false"`
}

type VNCAddressFinder interface {
	VNCAddress(context.Context, string, int, int) (string, int, error)

	// UpdateVMX, sets driver specific VNC values to VMX data.
	UpdateVMX(vncAddress, vncPassword string, vncPort int, vmxData map[string]string)
}

type VNCBootCommandTemplateData struct {
	HTTPIP       string
	HTTPPort     int
	Name         string
	SSHPublicKey string
}

type VmwareDriver struct {
	/// These methods define paths that are utilized by the driver
	/// A driver must overload these in order to point to the correct
	/// files so that the address detection (ip and ethernet) machinery
	/// works.
	DhcpLeasesPath   func(string) string
	DhcpConfPath     func(string) string
	VmnetnatConfPath func(string) string

	/// This method returns an object with the NetworkNameMapper interface
	/// that maps network to device and vice-versa.
	NetworkMapper func() (NetworkNameMapper, error)
}

type Workstation10Driver struct {
	Workstation9Driver
}

type Workstation9Driver struct {
	VmwareDriver

	AppPath          string
	VdiskManagerPath string
	VmrunPath        string

	// SSHConfig are the SSH settings for the Fusion VM
	SSHConfig *SSHConfig
}