Class List Method List File List

# Class: Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType

Inherits:
  VAPI::Bindings::VapiEnum
  - Object
  - VAPI::Bindings::VapiEnum
  - Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType
  show all
Defined in:
  /build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vcenter/vm/hardware.rb

## Overview

The ``Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`` enumerated type defines the valid backing types for a virtual serial port.

## Constant Summary

FILE =

      BackingType.new('FILE')

HOST_DEVICE =

      BackingType.new('HOST_DEVICE')

PIPE_SERVER =

      BackingType.new('PIPE_SERVER')

PIPE_CLIENT =

      BackingType.new('PIPE_CLIENT')

NETWORK_SERVER =

      BackingType.new('NETWORK_SERVER')

NETWORK_CLIENT =

      BackingType.new('NETWORK_CLIENT')

## Instance Attribute Summary (collapse)

- - (Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType) file

  Virtual serial port is backed by a file.

- - (Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType) host_device

  Virtual serial port is backed by a device on the host where the virtual machine is running.

- - (Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType) network_client

  Virtual serial port is backed by a network client.

- - (Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType) network_server

  Virtual serial port is backed by a network server.

- - (Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType) pipe_client

  Virtual serial port is backed by a named pipe client.

- - (Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType) pipe_server

  Virtual serial port is backed by a named pipe server.

## Class Method Summary (collapse)

- + (VAPI::Bindings::EnumType) binding_type

  Holds (gets or creates) the binding type metadata for this enumeration type.

- + (BackingType) from_string(value)

  Converts from a string value (perhaps off the wire) to an instance of this enum type.

## Instance Attribute Details

### - (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`) file

Virtual serial port is backed by a file.

Returns:

- (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`)

    5719
    5720
    5721
    5722
    5723
    5724
    5725
    5726
    5727
    5728
    5729
    5730
    5731
    5732
    5733
    5734
    5735
    5736
    5737
    5738
    5739
    5740
    5741
    5742
    5743
    5744
    5745
    5746
    5747
    5748
    5749
    5750
    5751
    5752
    5753
    5754
    5755
    5756
    5757
    5758
    5759
    5760
    5761
    5762
    5763
    5764
    5765
    5766
    5767
    5768
    5769
    5770
    5771
    5772
    5773
    5774
    5775
    5776
    5777
    5778
    5779
    5780
    5781
    5782
    5783
    5784
    5785
    5786
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vcenter/vm/hardware.rb', line 5719

    class BackingType < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.vcenter.vm.hardware.serial.backing_type',
                    BackingType)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [BackingType] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    BackingType.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] file
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a file.
        FILE = BackingType.new('FILE')

        # @!attribute [rw] host_device
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a device on the host where the virtual machine is running.
        HOST_DEVICE = BackingType.new('HOST_DEVICE')

        # @!attribute [rw] pipe_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe server. The virtual machine will accept a connection from a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_SERVER = BackingType.new('PIPE_SERVER')

        # @!attribute [rw] pipe_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe client. The virtual machine will connect to the named pipe provided by a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_CLIENT = BackingType.new('PIPE_CLIENT')

        # @!attribute [rw] network_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network server. This backing may be used to create a network-accessible serial port on the virtual machine, accepting a connection from a remote system.
        NETWORK_SERVER = BackingType.new('NETWORK_SERVER')

        # @!attribute [rw] network_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network client. This backing may be used to create a network-accessible serial port on the virtual machine, initiating a connection to a remote system.
        NETWORK_CLIENT = BackingType.new('NETWORK_CLIENT')

    end

### - (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`) host_device

Virtual serial port is backed by a device on the host where the virtual machine is running.

Returns:

- (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`)

    5719
    5720
    5721
    5722
    5723
    5724
    5725
    5726
    5727
    5728
    5729
    5730
    5731
    5732
    5733
    5734
    5735
    5736
    5737
    5738
    5739
    5740
    5741
    5742
    5743
    5744
    5745
    5746
    5747
    5748
    5749
    5750
    5751
    5752
    5753
    5754
    5755
    5756
    5757
    5758
    5759
    5760
    5761
    5762
    5763
    5764
    5765
    5766
    5767
    5768
    5769
    5770
    5771
    5772
    5773
    5774
    5775
    5776
    5777
    5778
    5779
    5780
    5781
    5782
    5783
    5784
    5785
    5786
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vcenter/vm/hardware.rb', line 5719

    class BackingType < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.vcenter.vm.hardware.serial.backing_type',
                    BackingType)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [BackingType] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    BackingType.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] file
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a file.
        FILE = BackingType.new('FILE')

        # @!attribute [rw] host_device
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a device on the host where the virtual machine is running.
        HOST_DEVICE = BackingType.new('HOST_DEVICE')

        # @!attribute [rw] pipe_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe server. The virtual machine will accept a connection from a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_SERVER = BackingType.new('PIPE_SERVER')

        # @!attribute [rw] pipe_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe client. The virtual machine will connect to the named pipe provided by a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_CLIENT = BackingType.new('PIPE_CLIENT')

        # @!attribute [rw] network_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network server. This backing may be used to create a network-accessible serial port on the virtual machine, accepting a connection from a remote system.
        NETWORK_SERVER = BackingType.new('NETWORK_SERVER')

        # @!attribute [rw] network_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network client. This backing may be used to create a network-accessible serial port on the virtual machine, initiating a connection to a remote system.
        NETWORK_CLIENT = BackingType.new('NETWORK_CLIENT')

    end

### - (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`) network_client

Virtual serial port is backed by a network client. This backing may be used to create a network-accessible serial port on the virtual machine, initiating a connection to a remote system.

Returns:

- (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`)

    5719
    5720
    5721
    5722
    5723
    5724
    5725
    5726
    5727
    5728
    5729
    5730
    5731
    5732
    5733
    5734
    5735
    5736
    5737
    5738
    5739
    5740
    5741
    5742
    5743
    5744
    5745
    5746
    5747
    5748
    5749
    5750
    5751
    5752
    5753
    5754
    5755
    5756
    5757
    5758
    5759
    5760
    5761
    5762
    5763
    5764
    5765
    5766
    5767
    5768
    5769
    5770
    5771
    5772
    5773
    5774
    5775
    5776
    5777
    5778
    5779
    5780
    5781
    5782
    5783
    5784
    5785
    5786
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vcenter/vm/hardware.rb', line 5719

    class BackingType < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.vcenter.vm.hardware.serial.backing_type',
                    BackingType)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [BackingType] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    BackingType.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] file
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a file.
        FILE = BackingType.new('FILE')

        # @!attribute [rw] host_device
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a device on the host where the virtual machine is running.
        HOST_DEVICE = BackingType.new('HOST_DEVICE')

        # @!attribute [rw] pipe_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe server. The virtual machine will accept a connection from a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_SERVER = BackingType.new('PIPE_SERVER')

        # @!attribute [rw] pipe_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe client. The virtual machine will connect to the named pipe provided by a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_CLIENT = BackingType.new('PIPE_CLIENT')

        # @!attribute [rw] network_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network server. This backing may be used to create a network-accessible serial port on the virtual machine, accepting a connection from a remote system.
        NETWORK_SERVER = BackingType.new('NETWORK_SERVER')

        # @!attribute [rw] network_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network client. This backing may be used to create a network-accessible serial port on the virtual machine, initiating a connection to a remote system.
        NETWORK_CLIENT = BackingType.new('NETWORK_CLIENT')

    end

### - (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`) network_server

Virtual serial port is backed by a network server. This backing may be used to create a network-accessible serial port on the virtual machine, accepting a connection from a remote system.

Returns:

- (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`)

    5719
    5720
    5721
    5722
    5723
    5724
    5725
    5726
    5727
    5728
    5729
    5730
    5731
    5732
    5733
    5734
    5735
    5736
    5737
    5738
    5739
    5740
    5741
    5742
    5743
    5744
    5745
    5746
    5747
    5748
    5749
    5750
    5751
    5752
    5753
    5754
    5755
    5756
    5757
    5758
    5759
    5760
    5761
    5762
    5763
    5764
    5765
    5766
    5767
    5768
    5769
    5770
    5771
    5772
    5773
    5774
    5775
    5776
    5777
    5778
    5779
    5780
    5781
    5782
    5783
    5784
    5785
    5786
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vcenter/vm/hardware.rb', line 5719

    class BackingType < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.vcenter.vm.hardware.serial.backing_type',
                    BackingType)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [BackingType] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    BackingType.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] file
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a file.
        FILE = BackingType.new('FILE')

        # @!attribute [rw] host_device
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a device on the host where the virtual machine is running.
        HOST_DEVICE = BackingType.new('HOST_DEVICE')

        # @!attribute [rw] pipe_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe server. The virtual machine will accept a connection from a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_SERVER = BackingType.new('PIPE_SERVER')

        # @!attribute [rw] pipe_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe client. The virtual machine will connect to the named pipe provided by a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_CLIENT = BackingType.new('PIPE_CLIENT')

        # @!attribute [rw] network_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network server. This backing may be used to create a network-accessible serial port on the virtual machine, accepting a connection from a remote system.
        NETWORK_SERVER = BackingType.new('NETWORK_SERVER')

        # @!attribute [rw] network_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network client. This backing may be used to create a network-accessible serial port on the virtual machine, initiating a connection to a remote system.
        NETWORK_CLIENT = BackingType.new('NETWORK_CLIENT')

    end

### - (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`) pipe_client

Virtual serial port is backed by a named pipe client. The virtual machine will connect to the named pipe provided by a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.

Returns:

- (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`)

    5719
    5720
    5721
    5722
    5723
    5724
    5725
    5726
    5727
    5728
    5729
    5730
    5731
    5732
    5733
    5734
    5735
    5736
    5737
    5738
    5739
    5740
    5741
    5742
    5743
    5744
    5745
    5746
    5747
    5748
    5749
    5750
    5751
    5752
    5753
    5754
    5755
    5756
    5757
    5758
    5759
    5760
    5761
    5762
    5763
    5764
    5765
    5766
    5767
    5768
    5769
    5770
    5771
    5772
    5773
    5774
    5775
    5776
    5777
    5778
    5779
    5780
    5781
    5782
    5783
    5784
    5785
    5786
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vcenter/vm/hardware.rb', line 5719

    class BackingType < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.vcenter.vm.hardware.serial.backing_type',
                    BackingType)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [BackingType] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    BackingType.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] file
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a file.
        FILE = BackingType.new('FILE')

        # @!attribute [rw] host_device
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a device on the host where the virtual machine is running.
        HOST_DEVICE = BackingType.new('HOST_DEVICE')

        # @!attribute [rw] pipe_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe server. The virtual machine will accept a connection from a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_SERVER = BackingType.new('PIPE_SERVER')

        # @!attribute [rw] pipe_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe client. The virtual machine will connect to the named pipe provided by a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_CLIENT = BackingType.new('PIPE_CLIENT')

        # @!attribute [rw] network_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network server. This backing may be used to create a network-accessible serial port on the virtual machine, accepting a connection from a remote system.
        NETWORK_SERVER = BackingType.new('NETWORK_SERVER')

        # @!attribute [rw] network_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network client. This backing may be used to create a network-accessible serial port on the virtual machine, initiating a connection to a remote system.
        NETWORK_CLIENT = BackingType.new('NETWORK_CLIENT')

    end

### - (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`) pipe_server

Virtual serial port is backed by a named pipe server. The virtual machine will accept a connection from a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.

Returns:

- (`Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType`)

    5719
    5720
    5721
    5722
    5723
    5724
    5725
    5726
    5727
    5728
    5729
    5730
    5731
    5732
    5733
    5734
    5735
    5736
    5737
    5738
    5739
    5740
    5741
    5742
    5743
    5744
    5745
    5746
    5747
    5748
    5749
    5750
    5751
    5752
    5753
    5754
    5755
    5756
    5757
    5758
    5759
    5760
    5761
    5762
    5763
    5764
    5765
    5766
    5767
    5768
    5769
    5770
    5771
    5772
    5773
    5774
    5775
    5776
    5777
    5778
    5779
    5780
    5781
    5782
    5783
    5784
    5785
    5786
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vcenter/vm/hardware.rb', line 5719

    class BackingType < VAPI::Bindings::VapiEnum

        class << self
            # Holds (gets or creates) the binding type metadata for this enumeration type.
            # @scope class
            # @return [VAPI::Bindings::EnumType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::EnumType.new(
                    'com.vmware.vcenter.vm.hardware.serial.backing_type',
                    BackingType)
            end

            # Converts from a string value (perhaps off the wire) to an instance
            # of this enum type.
            # @param value [String] the actual value of the enum instance
            # @return [BackingType] the instance found for the value, otherwise
            #         an unknown instance will be built for the value
            def from_string(value)
                begin
                    const_get(value)
                rescue NameError
                    BackingType.new('UNKNOWN', value)
                end
            end
        end

        private

        # Constructs a new instance.
        # @param value [String] the actual value of the enum instance
        # @param unknown [String] the unknown value when value is 'UKNOWN'
        def initialize(value, unknown=nil)
            super(self.class.binding_type, value, unknown)
        end

        public

        # @!attribute [rw] file
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a file.
        FILE = BackingType.new('FILE')

        # @!attribute [rw] host_device
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a device on the host where the virtual machine is running.
        HOST_DEVICE = BackingType.new('HOST_DEVICE')

        # @!attribute [rw] pipe_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe server. The virtual machine will accept a connection from a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_SERVER = BackingType.new('PIPE_SERVER')

        # @!attribute [rw] pipe_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a named pipe client. The virtual machine will connect to the named pipe provided by a host application or another virtual machine on the same host. This is useful for capturing debugging information sent through the virtual serial port.
        PIPE_CLIENT = BackingType.new('PIPE_CLIENT')

        # @!attribute [rw] network_server
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network server. This backing may be used to create a network-accessible serial port on the virtual machine, accepting a connection from a remote system.
        NETWORK_SERVER = BackingType.new('NETWORK_SERVER')

        # @!attribute [rw] network_client
        #     @return [Com::Vmware::Vcenter::Vm::Hardware::Serial::BackingType]
        #     Virtual serial port is backed by a network client. This backing may be used to create a network-accessible serial port on the virtual machine, initiating a connection to a remote system.
        NETWORK_CLIENT = BackingType.new('NETWORK_CLIENT')

    end

## Class Method Details

### + (`VAPI::Bindings::EnumType`) binding_type

Holds (gets or creates) the binding type metadata for this enumeration type.

Returns:

- (`VAPI::Bindings::EnumType`) —

  the binding type

    5725
    5726
    5727
    5728
    5729
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vcenter/vm/hardware.rb', line 5725

    def binding_type
        @binding_type ||= VAPI::Bindings::EnumType.new(
            'com.vmware.vcenter.vm.hardware.serial.backing_type',
            BackingType)
    end

### + (`BackingType`) from_string(value)

Converts from a string value (perhaps off the wire) to an instance of this enum type.

Parameters:

- value (`String`) —

  the actual value of the enum instance

Returns:

- (`BackingType`) —

  the instance found for the value, otherwise an unknown instance will be built for the value

    5736
    5737
    5738
    5739
    5740
    5741
    5742
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/vcenter/vm/hardware.rb', line 5736

    def from_string(value)
        begin
            const_get(value)
        rescue NameError
            BackingType.new('UNKNOWN', value)
        end
    end