Class List Method List File List

# Class: Com::Vmware::Content::LibraryModel

Inherits:
  VAPI::Bindings::VapiStruct
  - Object
  - VAPI::Bindings::VapiStruct
  - Com::Vmware::Content::LibraryModel
  show all
Defined in:
  /build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb

## Overview

The :class:`Com::Vmware::Content::LibraryModel` class represents a Content Library resource model.

     A  ``Com::Vmware::Content::LibraryModel``  is a container for a set of items which represent a usable set of files. The Content Library Service allows for multiple libraries to be created with separate authorization and sharing policies.

     Each  ``Com::Vmware::Content::LibraryModel``  is a container for a set of   :class:`Com::Vmware::Content::Library::ItemModel`   instances. Each item is a logical object in a library, which may have multiple files.

     A  ``Com::Vmware::Content::LibraryModel``  may be local or subscribed. A local library has its source of truth about items within this Content Library Service. Items may be added to or removed from the library. A local library may also be private or published. When published, the library is exposed by a network endpoint and can be used by another Content Library Service for synchronization. A private local library cannot be used for synchronization.

     A subscribed library is a library which gets its source of truth from another library that may be across a network in another Content Library Service. A subscribed library may have a different name and metadata from the library to which it subscribes, but the set of library items is always the same as those in the source library. Library items cannot be manually added to a subscribed library -- they can only be added by adding new items to the source library.

## Defined Under Namespace

Classes: LibraryType

## Instance Attribute Summary (collapse)

- - (DateTime) creation_time

  The date and time when this library was created.

- - (String) description

  A human-readable description for this library.

- - (String) id

  An identifier which uniquely identifies this ``Com::Vmware::Content::LibraryModel`` .

- - (DateTime) last_modified_time

  The date and time when this library was last updated.

- - (DateTime) last_sync_time

  The date and time when this library was last synchronized.

- - (String) name

  The name of the library.

- - (Com::Vmware::Content::Library::OptimizationInfo) optimization_info

  Defines various optimizations and optimization parameters applied to this library.

- - (Com::Vmware::Content::Library::PublishInfo) publish_info

  Defines how this library is published so that it can be subscribed to by a remote subscribed library.

- - (String) server_guid

  The unique identifier of the vCenter server where the library exists.

- - (Array<Com::Vmware::Content::Library::StorageBacking>) storage_backings

  The list of storage backings which are available for this library.

- - (Com::Vmware::Content::Library::SubscriptionInfo) subscription_info

  Defines the subscription behavior for this Library.

- - (Com::Vmware::Content::LibraryModel::LibraryType) type

  The type ( ``LOCAL``, ``SUBSCRIBED`` ) of this library.

- - (String) version

  A version number which is updated on metadata changes.

## 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)

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

  Constructs a new instance.

## Constructor Details

### - (`LibraryModel`) 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)

    1185
    1186
    1187
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1185

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

## Instance Attribute Details

### - (`DateTime`) creation_time

The date and time when this library was created. This field is not used for the ``create`` method . It will always be present in the result of the ``get`` or ``list`` methods . It is not used for the ``update`` method .

Returns:

- (`DateTime`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`String`) description

A human-readable description for this library. This field is optional for the ``create`` method . Leaving it nil during creation will result in an empty string value. It will always be present in the result of a ``get`` or ``list`` method . It is optional for the ``update`` method . Leaving it nil during update indicates that the description should be left unchanged.

Returns:

- (`String`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`String`) id

An identifier which uniquely identifies this ``Com::Vmware::Content::LibraryModel`` . This field is not used for the ``create`` method . It will not be present in the result of the ``get`` or ``list`` methods . It is not used for the ``update`` method .

Returns:

- (`String`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`DateTime`) last_modified_time

The date and time when this library was last updated.

     This  field  is updated automatically when the library properties are changed. This  field  is not affected by adding, removing, or modifying a library item or its content within the library. Tagging the library or syncing the subscribed library does not alter this  field .

This field is not used for the ``create`` method . It will always be present in the result of the ``get`` or ``list`` methods . It is not used for the ``update`` method .

Returns:

- (`DateTime`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`DateTime`) last_sync_time

The date and time when this library was last synchronized.

     This  field  applies only to subscribed libraries. It is updated every time a synchronization is triggered on the library. The value is  nil  for a local library.

This field is not used for the ``create`` method . It is optional in the result of the ``get`` or ``list`` methods . It is not used for the ``update`` method .

Returns:

- (`DateTime`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`String`) name

The name of the library.

     A Library is identified by a human-readable name. Library names cannot be undefined or an empty string. Names do not have to be unique.

This field must be provided for the ``create`` method . It will always be present in the result of the ``get`` or ``list`` methods . It is optional for the ``update`` method .

Returns:

- (`String`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`Com::Vmware::Content::Library::OptimizationInfo`) optimization_info

Defines various optimizations and optimization parameters applied to this library. This field is optional for the ``create`` method . It is optional in the result of the ``get`` or ``list`` methods . It is optional for the ``update`` method .

Returns:

- (`Com::Vmware::Content::Library::OptimizationInfo`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`Com::Vmware::Content::Library::PublishInfo`) publish_info

Defines how this library is published so that it can be subscribed to by a remote subscribed library.

     The   :class:`Com::Vmware::Content::Library::PublishInfo`   defines where and how the metadata for this local library is accessible. A local library is only published publically if   :attr:`Com::Vmware::Content::Library::PublishInfo.published`   is  ``true`` .

This field is optional for the ``create`` and ``update`` methods . If not specified during creation, the default is for the library to not be published. If not specified during update, the field is left unchanged.

Returns:

- (`Com::Vmware::Content::Library::PublishInfo`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`String`) server_guid

The unique identifier of the vCenter server where the library exists. This field is optional for the ``create`` method . It will always be present in the result of the ``get`` or ``list`` methods . It is not used for the ``update`` method .

Returns:

- (`String`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`Array<Com::Vmware::Content::Library::StorageBacking>`) storage_backings

The list of storage backings which are available for this library.

     A   :class:`Com::Vmware::Content::Library::StorageBacking`   defines a storage location which can be used to store files for the library items in this library. Multiple storage locations are not currently supported but may become supported in future releases.

This field must be provided for the ``create`` method . It will always be present in the result of the ``get`` or ``list`` methods . It is not used for the ``update`` method .

Returns:

- (`Array<Com::Vmware::Content::Library::StorageBacking>`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`Com::Vmware::Content::Library::SubscriptionInfo`) subscription_info

Defines the subscription behavior for this Library.

     The   :class:`Com::Vmware::Content::Library::SubscriptionInfo`   defines how this subscribed library synchronizes to a remote source. Setting the value will determine the remote source to which the library synchronizes, and how. Changing the subscription will result in synchronizing to a new source. If the new source differs from the old one, the old library items and data will be lost. Setting   :attr:`Com::Vmware::Content::Library::SubscriptionInfo.automatic_sync_enabled`   to false will halt subscription but will not remove existing cached data.

This field is optional for the ``create`` and ``update`` methods . If not specified during creation, a default will be created without an active subscription. If not specified during update, the field is left unchanged.

Returns:

- (`Com::Vmware::Content::Library::SubscriptionInfo`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`Com::Vmware::Content::LibraryModel::LibraryType`) type

The type ( ``LOCAL``, ``SUBSCRIBED`` ) of this library.

     This value can be used to determine what additional services and information can be available for this library.

This field must be provided for the ``create`` method . It will always be present in the result of the ``get`` or ``list`` methods . It is not used for the ``update`` method .

Returns:

- (`Com::Vmware::Content::LibraryModel::LibraryType`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        end

    end

### - (`String`) version

A version number which is updated on metadata changes. This value allows clients to detect concurrent updates and prevent accidental clobbering of data.

     This value represents a number which is incremented every time library properties, such as name or description, are changed. It is not incremented by changes to a library item within the library, including adding or removing items. It is also not affected by tagging the library.

This field is not used for the ``create`` method . It will always be present in the result of a ``get`` or ``list`` method . It is optional for the ``update`` method . Leaving it nil during update indicates that you do not need to detect concurrent updates.

Returns:

- (`String`)

    1138
    1139
    1140
    1141
    1142
    1143
    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    1166
    1167
    1168
    1169
    1170
    1171
    1172
    1173
    1174
    1175
    1176
    1177
    1178
    1179
    1180
    1181
    1182
    1183
    1184
    1185
    1186
    1187
    1188
    1189
    1190
    1191
    1192
    1193
    1194
    1195
    1196
    1197
    1198
    1199
    1200
    1201
    1202
    1203
    1204
    1205
    1206
    1207
    1208
    1209
    1210
    1211
    1212
    1213
    1214
    1215
    1216
    1217
    1218
    1219
    1220
    1221
    1222
    1223
    1224
    1225
    1226
    1227
    1228
    1229
    1230
    1231
    1232
    1233
    1234
    1235
    1236
    1237
    1238
    1239
    1240
    1241
    1242
    1243
    1244
    1245
    1246
    1247
    1248
    1249
    1250
    1251
    1252
    1253
    1254
    1255
    1256
    1257
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1138

    class LibraryModel < 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.content.library_model',
                    {
                        'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                        'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                        'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                        'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                        'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                        'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                        'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                        'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                        'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                    },
                    LibraryModel,
                    true,
                    ["id"])
            end
        end

        attr_accessor :id,
                      :creation_time,
                      :description,
                      :last_modified_time,
                      :last_sync_time,
                      :name,
                      :storage_backings,
                      :type,
                      :optimization_info,
                      :version,
                      :publish_info,
                      :subscription_info,
                      :server_guid

        # 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::Content::LibraryModel::LibraryType``   enumerated type  defines the type of a   :class:`Com::Vmware::Content::LibraryModel`  .
        #
        #  The type of a library can be used to determine which additional services can be performed with a library.
        # @!attribute [rw] local
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library contents are defined and stored by the local Content Library Service installation.
        #
        #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
        # @!attribute [rw] subscribed
        #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
        #     The library synchronizes its items and content from another published library.
        #
        #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
        class LibraryType < 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.content.library_model.library_type',
                        LibraryType)
                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 [LibraryType] 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
                        LibraryType.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] local
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library contents are defined and stored by the local Content Library Service installation.
            #
            #      A local library can be retrieved and managed via the   :class:`Com::Vmware::Content::LocalLibrary`  .
            LOCAL = LibraryType.new('LOCAL')

            # @!attribute [rw] subscribed
            #     @return [Com::Vmware::Content::LibraryModel::LibraryType]
            #     The library synchronizes its items and content from another published library.
            #
            #      A subscribed library can be retrieved and managed via the   :class:`Com::Vmware::Content::SubscribedLibrary`  .
            SUBSCRIBED = LibraryType.new('SUBSCRIBED')

        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

    1144
    1145
    1146
    1147
    1148
    1149
    1150
    1151
    1152
    1153
    1154
    1155
    1156
    1157
    1158
    1159
    1160
    1161
    1162
    1163
    1164
    1165
    # File '/build/mts/release/bora-4571906/build/sdk/aggregated-bindings/ruby/com/vmware/content.rb', line 1144

    def binding_type
        @binding_type ||= VAPI::Bindings::StructType.new(
            'com.vmware.content.library_model',
            {
                'id' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
                'creation_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                'description' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                'last_modified_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                'last_sync_time' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::DateTimeType.instance),
                'name' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                'storage_backings' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ListType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::StorageBacking'))),
                'type' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::LibraryModel::LibraryType')),
                'optimization_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::OptimizationInfo')),
                'version' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::StringType.instance),
                'publish_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::PublishInfo')),
                'subscription_info' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::ReferenceType.new('Com::Vmware::Content::Library::SubscriptionInfo')),
                'server_guid' => VAPI::Bindings::OptionalType.new(VAPI::Bindings::IdType.new),
            },
            LibraryModel,
            true,
            ["id"])
    end