Class List Method List File List

# Class: Com::Vmware::Cis::Tagging::CategoryModel

Inherits:
  VAPI::Bindings::VapiStruct
  - Object
  - VAPI::Bindings::VapiStruct
  - Com::Vmware::Cis::Tagging::CategoryModel
  show all
Defined in:
  /build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb

## Overview

The ``Com::Vmware::Cis::Tagging::CategoryModel`` class defines a category that is used to group one or more tags.

## Defined Under Namespace

Classes: Cardinality

## Instance Attribute Summary (collapse)

- - (Set<String>) associable_types

  The types of objects that the tags in this category can be attached to.

- - (Com::Vmware::Cis::Tagging::CategoryModel::Cardinality) cardinality

  The associated cardinality ( ``SINGLE``, ``MULTIPLE`` ) of the category.

- - (String) description

  The description of the category.

- - (String) id

  The unique identifier of the category.

- - (String) name

  The display name of the category.

- - (Set<String>) used_by

  The set of users that can use this category.

## Class Method Summary (collapse)

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

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

## Instance Method Summary (collapse)

- - (CategoryModel) initialize(ruby_values = nil, struct_value = nil) constructor

  Constructs a new instance.

## Constructor Details

### - (`CategoryModel`) initialize(ruby_values = nil, struct_value = nil)

Constructs a new instance.

Parameters:

- ruby_values (`Hash`) (defaults to: `nil`) —

  a map of initial property values (optional)

- struct_value (`VAPI::Data::StructValue`) (defaults to: `nil`) —

  a raw StructValue from the wire (optional)

    1378
    1379
    1380
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1378

    def initialize(ruby_values=nil, struct_value=nil)
        super(self.class.binding_type, ruby_values, struct_value)
    end

## Instance Attribute Details

### - (`Set<String>`) associable_types

The types of objects that the tags in this category can be attached to. If the set is empty, then tags can be attached to all types of objects. This field works only for objects that reside in Inventory Service (IS). For non IS objects, this check is not performed today and hence a tag can be attached to any non IS object.

Returns:

- (`Set<String>`)

    1345
    1346
    1347
    1348
    1349
    1350
    1351
    1352
    1353
    1354
    1355
    1356
    1357
    1358
    1359
    1360
    1361
    1362
    1363
    1364
    1365
    1366
    1367
    1368
    1369
    1370
    1371
    1372
    1373
    1374
    1375
    1376
    1377
    1378
    1379
    1380
    1381
    1382
    1383
    1384
    1385
    1386
    1387
    1388
    1389
    1390
    1391
    1392
    1393
    1394
    1395
    1396
    1397
    1398
    1399
    1400
    1401
    1402
    1403
    1404
    1405
    1406
    1407
    1408
    1409
    1410
    1411
    1412
    1413
    1414
    1415
    1416
    1417
    1418
    1419
    1420
    1421
    1422
    1423
    1424
    1425
    1426
    1427
    1428
    1429
    1430
    1431
    1432
    1433
    1434
    1435
    1436
    1437
    1438
    1439
    1440
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

    class CategoryModel < VAPI::Bindings::VapiStruct

        class << self
            # Holds (gets or creates) the binding type metadata for this structure type.
            # @scope class
            # @return [VAPI::Bindings::StructType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::StructType.new(
                    'com.vmware.cis.tagging.category_model',
                    {
                        'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                        'name' => VAPI::Bindings::StringType.instance,
                        'description' => VAPI::Bindings::StringType.instance,
                        'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                        'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                        'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    },
                    CategoryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :name,
                      :description,
                      :cardinality,
                      :associable_types,
                      :used_by

        # Constructs a new instance.
        # @param ruby_values [Hash] a map of initial property values (optional)
        # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
        def initialize(ruby_values=nil, struct_value=nil)
            super(self.class.binding_type, ruby_values, struct_value)
        end

        # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        class Cardinality < 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.cis.tagging.category_model.cardinality',
                        Cardinality)
                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 [Cardinality] 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
                        Cardinality.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] single
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
            SINGLE = Cardinality.new('SINGLE')

            # @!attribute [rw] multiple
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
            MULTIPLE = Cardinality.new('MULTIPLE')

        end

    end

### - (`Com::Vmware::Cis::Tagging::CategoryModel::Cardinality`) cardinality

The associated cardinality ( ``SINGLE``, ``MULTIPLE`` ) of the category.

Returns:

- (`Com::Vmware::Cis::Tagging::CategoryModel::Cardinality`)

    1345
    1346
    1347
    1348
    1349
    1350
    1351
    1352
    1353
    1354
    1355
    1356
    1357
    1358
    1359
    1360
    1361
    1362
    1363
    1364
    1365
    1366
    1367
    1368
    1369
    1370
    1371
    1372
    1373
    1374
    1375
    1376
    1377
    1378
    1379
    1380
    1381
    1382
    1383
    1384
    1385
    1386
    1387
    1388
    1389
    1390
    1391
    1392
    1393
    1394
    1395
    1396
    1397
    1398
    1399
    1400
    1401
    1402
    1403
    1404
    1405
    1406
    1407
    1408
    1409
    1410
    1411
    1412
    1413
    1414
    1415
    1416
    1417
    1418
    1419
    1420
    1421
    1422
    1423
    1424
    1425
    1426
    1427
    1428
    1429
    1430
    1431
    1432
    1433
    1434
    1435
    1436
    1437
    1438
    1439
    1440
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

    class CategoryModel < VAPI::Bindings::VapiStruct

        class << self
            # Holds (gets or creates) the binding type metadata for this structure type.
            # @scope class
            # @return [VAPI::Bindings::StructType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::StructType.new(
                    'com.vmware.cis.tagging.category_model',
                    {
                        'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                        'name' => VAPI::Bindings::StringType.instance,
                        'description' => VAPI::Bindings::StringType.instance,
                        'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                        'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                        'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    },
                    CategoryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :name,
                      :description,
                      :cardinality,
                      :associable_types,
                      :used_by

        # Constructs a new instance.
        # @param ruby_values [Hash] a map of initial property values (optional)
        # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
        def initialize(ruby_values=nil, struct_value=nil)
            super(self.class.binding_type, ruby_values, struct_value)
        end

        # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        class Cardinality < 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.cis.tagging.category_model.cardinality',
                        Cardinality)
                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 [Cardinality] 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
                        Cardinality.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] single
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
            SINGLE = Cardinality.new('SINGLE')

            # @!attribute [rw] multiple
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
            MULTIPLE = Cardinality.new('MULTIPLE')

        end

    end

### - (`String`) description

The description of the category.

Returns:

- (`String`)

    1345
    1346
    1347
    1348
    1349
    1350
    1351
    1352
    1353
    1354
    1355
    1356
    1357
    1358
    1359
    1360
    1361
    1362
    1363
    1364
    1365
    1366
    1367
    1368
    1369
    1370
    1371
    1372
    1373
    1374
    1375
    1376
    1377
    1378
    1379
    1380
    1381
    1382
    1383
    1384
    1385
    1386
    1387
    1388
    1389
    1390
    1391
    1392
    1393
    1394
    1395
    1396
    1397
    1398
    1399
    1400
    1401
    1402
    1403
    1404
    1405
    1406
    1407
    1408
    1409
    1410
    1411
    1412
    1413
    1414
    1415
    1416
    1417
    1418
    1419
    1420
    1421
    1422
    1423
    1424
    1425
    1426
    1427
    1428
    1429
    1430
    1431
    1432
    1433
    1434
    1435
    1436
    1437
    1438
    1439
    1440
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

    class CategoryModel < VAPI::Bindings::VapiStruct

        class << self
            # Holds (gets or creates) the binding type metadata for this structure type.
            # @scope class
            # @return [VAPI::Bindings::StructType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::StructType.new(
                    'com.vmware.cis.tagging.category_model',
                    {
                        'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                        'name' => VAPI::Bindings::StringType.instance,
                        'description' => VAPI::Bindings::StringType.instance,
                        'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                        'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                        'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    },
                    CategoryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :name,
                      :description,
                      :cardinality,
                      :associable_types,
                      :used_by

        # Constructs a new instance.
        # @param ruby_values [Hash] a map of initial property values (optional)
        # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
        def initialize(ruby_values=nil, struct_value=nil)
            super(self.class.binding_type, ruby_values, struct_value)
        end

        # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        class Cardinality < 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.cis.tagging.category_model.cardinality',
                        Cardinality)
                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 [Cardinality] 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
                        Cardinality.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] single
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
            SINGLE = Cardinality.new('SINGLE')

            # @!attribute [rw] multiple
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
            MULTIPLE = Cardinality.new('MULTIPLE')

        end

    end

### - (`String`) id

The unique identifier of the category.

Returns:

- (`String`)

    1345
    1346
    1347
    1348
    1349
    1350
    1351
    1352
    1353
    1354
    1355
    1356
    1357
    1358
    1359
    1360
    1361
    1362
    1363
    1364
    1365
    1366
    1367
    1368
    1369
    1370
    1371
    1372
    1373
    1374
    1375
    1376
    1377
    1378
    1379
    1380
    1381
    1382
    1383
    1384
    1385
    1386
    1387
    1388
    1389
    1390
    1391
    1392
    1393
    1394
    1395
    1396
    1397
    1398
    1399
    1400
    1401
    1402
    1403
    1404
    1405
    1406
    1407
    1408
    1409
    1410
    1411
    1412
    1413
    1414
    1415
    1416
    1417
    1418
    1419
    1420
    1421
    1422
    1423
    1424
    1425
    1426
    1427
    1428
    1429
    1430
    1431
    1432
    1433
    1434
    1435
    1436
    1437
    1438
    1439
    1440
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

    class CategoryModel < VAPI::Bindings::VapiStruct

        class << self
            # Holds (gets or creates) the binding type metadata for this structure type.
            # @scope class
            # @return [VAPI::Bindings::StructType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::StructType.new(
                    'com.vmware.cis.tagging.category_model',
                    {
                        'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                        'name' => VAPI::Bindings::StringType.instance,
                        'description' => VAPI::Bindings::StringType.instance,
                        'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                        'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                        'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    },
                    CategoryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :name,
                      :description,
                      :cardinality,
                      :associable_types,
                      :used_by

        # Constructs a new instance.
        # @param ruby_values [Hash] a map of initial property values (optional)
        # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
        def initialize(ruby_values=nil, struct_value=nil)
            super(self.class.binding_type, ruby_values, struct_value)
        end

        # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        class Cardinality < 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.cis.tagging.category_model.cardinality',
                        Cardinality)
                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 [Cardinality] 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
                        Cardinality.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] single
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
            SINGLE = Cardinality.new('SINGLE')

            # @!attribute [rw] multiple
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
            MULTIPLE = Cardinality.new('MULTIPLE')

        end

    end

### - (`String`) name

The display name of the category.

Returns:

- (`String`)

    1345
    1346
    1347
    1348
    1349
    1350
    1351
    1352
    1353
    1354
    1355
    1356
    1357
    1358
    1359
    1360
    1361
    1362
    1363
    1364
    1365
    1366
    1367
    1368
    1369
    1370
    1371
    1372
    1373
    1374
    1375
    1376
    1377
    1378
    1379
    1380
    1381
    1382
    1383
    1384
    1385
    1386
    1387
    1388
    1389
    1390
    1391
    1392
    1393
    1394
    1395
    1396
    1397
    1398
    1399
    1400
    1401
    1402
    1403
    1404
    1405
    1406
    1407
    1408
    1409
    1410
    1411
    1412
    1413
    1414
    1415
    1416
    1417
    1418
    1419
    1420
    1421
    1422
    1423
    1424
    1425
    1426
    1427
    1428
    1429
    1430
    1431
    1432
    1433
    1434
    1435
    1436
    1437
    1438
    1439
    1440
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

    class CategoryModel < VAPI::Bindings::VapiStruct

        class << self
            # Holds (gets or creates) the binding type metadata for this structure type.
            # @scope class
            # @return [VAPI::Bindings::StructType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::StructType.new(
                    'com.vmware.cis.tagging.category_model',
                    {
                        'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                        'name' => VAPI::Bindings::StringType.instance,
                        'description' => VAPI::Bindings::StringType.instance,
                        'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                        'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                        'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    },
                    CategoryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :name,
                      :description,
                      :cardinality,
                      :associable_types,
                      :used_by

        # Constructs a new instance.
        # @param ruby_values [Hash] a map of initial property values (optional)
        # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
        def initialize(ruby_values=nil, struct_value=nil)
            super(self.class.binding_type, ruby_values, struct_value)
        end

        # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        class Cardinality < 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.cis.tagging.category_model.cardinality',
                        Cardinality)
                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 [Cardinality] 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
                        Cardinality.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] single
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
            SINGLE = Cardinality.new('SINGLE')

            # @!attribute [rw] multiple
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
            MULTIPLE = Cardinality.new('MULTIPLE')

        end

    end

### - (`Set<String>`) used_by

The set of users that can use this category. To add users to this, you need to have the edit privilege on the category. Similarly, to unsubscribe from this category, you need the edit privilege on the category. You should not modify other users subscription from this set .

Returns:

- (`Set<String>`)

    1345
    1346
    1347
    1348
    1349
    1350
    1351
    1352
    1353
    1354
    1355
    1356
    1357
    1358
    1359
    1360
    1361
    1362
    1363
    1364
    1365
    1366
    1367
    1368
    1369
    1370
    1371
    1372
    1373
    1374
    1375
    1376
    1377
    1378
    1379
    1380
    1381
    1382
    1383
    1384
    1385
    1386
    1387
    1388
    1389
    1390
    1391
    1392
    1393
    1394
    1395
    1396
    1397
    1398
    1399
    1400
    1401
    1402
    1403
    1404
    1405
    1406
    1407
    1408
    1409
    1410
    1411
    1412
    1413
    1414
    1415
    1416
    1417
    1418
    1419
    1420
    1421
    1422
    1423
    1424
    1425
    1426
    1427
    1428
    1429
    1430
    1431
    1432
    1433
    1434
    1435
    1436
    1437
    1438
    1439
    1440
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1345

    class CategoryModel < VAPI::Bindings::VapiStruct

        class << self
            # Holds (gets or creates) the binding type metadata for this structure type.
            # @scope class
            # @return [VAPI::Bindings::StructType] the binding type
            def binding_type
                @binding_type ||= VAPI::Bindings::StructType.new(
                    'com.vmware.cis.tagging.category_model',
                    {
                        'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                        'name' => VAPI::Bindings::StringType.instance,
                        'description' => VAPI::Bindings::StringType.instance,
                        'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                        'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                        'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                    },
                    CategoryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :name,
                      :description,
                      :cardinality,
                      :associable_types,
                      :used_by

        # Constructs a new instance.
        # @param ruby_values [Hash] a map of initial property values (optional)
        # @param struct_value [VAPI::Data::StructValue] a raw StructValue from the wire (optional)
        def initialize(ruby_values=nil, struct_value=nil)
            super(self.class.binding_type, ruby_values, struct_value)
        end

        # The  ``Com::Vmware::Cis::Tagging::CategoryModel::Cardinality``   enumerated type  defines the number of tags in a category that can be assigned to an object.
        # @!attribute [rw] single
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
        # @!attribute [rw] multiple
        #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
        #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
        class Cardinality < 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.cis.tagging.category_model.cardinality',
                        Cardinality)
                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 [Cardinality] 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
                        Cardinality.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] single
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can only be assigned one of the tags in this category. For example, if a category is "Operating System", then different tags of this category would be "Windows", "Linux", and so on. In this case a VM object can be assigned only one of these tags and hence the cardinality of the associated category here is single.
            SINGLE = Cardinality.new('SINGLE')

            # @!attribute [rw] multiple
            #     @return [Com::Vmware::Cis::Tagging::CategoryModel::Cardinality]
            #     An object can be assigned several of the tags in this category. For example, if a category is "Server", then different tags of this category would be "AppServer", "DatabaseServer" and so on. In this case a VM object can be assigned more than one of the above tags and hence the cardinality of the associated category here is multiple.
            MULTIPLE = Cardinality.new('MULTIPLE')

        end

    end

## Class Method Details

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

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

Returns:

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

  the binding type

    1351
    1352
    1353
    1354
    1355
    1356
    1357
    1358
    1359
    1360
    1361
    1362
    1363
    1364
    1365
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/cis/tagging.rb', line 1351

    def binding_type
        @binding_type ||= VAPI::Bindings::StructType.new(
            'com.vmware.cis.tagging.category_model',
            {
                'id' => VAPI::Bindings::IdType.new(resource_types='com.vmware.cis.tagging.Category'),
                'name' => VAPI::Bindings::StringType.instance,
                'description' => VAPI::Bindings::StringType.instance,
                'cardinality' => VAPI::Bindings::ReferenceType.new('Com::Vmware::Cis::Tagging::CategoryModel::Cardinality'),
                'associable_types' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
                'used_by' => VAPI::Bindings::SetType.new(VAPI::Bindings::StringType.instance),
            },
            CategoryModel,
            true,
            ["id"])
    end