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)

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

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

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

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

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

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

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

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

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

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

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

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

# 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

# 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

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

Overview

Defined Under Namespace

Instance Attribute Summary (collapse)

Class Method Summary (collapse)

Instance Method Summary (collapse)

Constructor Details

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

Instance Attribute Details

- (DateTime) creation_time

- (String) description

- (String) id

- (DateTime) last_modified_time

- (DateTime) last_sync_time

- (String) name

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

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

- (String) server_guid

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

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

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

- (String) version

Class Method Details

+ (VAPI::Bindings::StructType) binding_type

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

- (`DateTime`) creation_time

- (`String`) description

- (`String`) id

- (`DateTime`) last_modified_time

- (`DateTime`) last_sync_time

- (`String`) name

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

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

- (`String`) server_guid

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

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

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

- (`String`) version

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