Provides classes and interfaces that are used in the administration of a FileNet P8 Content Engine server. These classes are used to configure servers and content storage devices within a geographical site, to configure full text indexing and directory service access parameters, and to perform related tasks. This namespace also contains the classes used to author custom metadata (the class and property definitions that define applicaton-specific metadata). Most of the administration classes reside in the FileNet P8 domain's Global Configuration Data (GCD) database, outside of any object store (although the metadata authoring objects are defined within an object store).


Classes

  Class Description
Public class ContentValidationRequest Represents a data object to be used with the batch form of StorageArea.ValidateContent.

Interfaces

  Interface Description
Public interface IAddOn Represents a product extension to the core FileNet P8 Content Engine components. These extensions consist of properties and/or classes to support a specific feature. Add-ons can be non-FileNet products that are compatible with FileNet P8, or they can be FileNet-supplied and provide additional functionality.

You can create an AddOn object by calling CreateInstance on the Factory.AddOn class. Creating an add-on automatically registers it in the FileNet P8 Global Configuration Data (GCD) database. A registered add-on can then be:

  • Installed during new object store creation.
  • Installed on an existing object store.
Public interface IAddOnInstallationRecord Represents a record that contains information pertaining to the installation of an add-on. An AddOnInstallationRecord object is created whenever an AddOn or UpgradeAddOn object is installed on an object store.
Public interface IAsyncProcessingConfiguration Represents configuration data for asynchronous processing of events. This class allows admininistrative clients to set or access event dispatcher configuration settings. An IAsyncProcessingConfiguration object can be assigned to objects of the server hierarchy (IDomain, ISite, IVirtualServer, and IServerInstance), and is persisted in the GCD.

To create a IAsyncProcessingConfiguration object, call the CreateInstance method on the IAsyncProcessingConfiguration class. To instantiate an IAsyncProcessingConfiguration object, retrieve the SubsystemConfigurations property from an object of the server hierarchy, then iterate the ISubsystemConfigurationList for the IAsyncProcessingConfiguration object.

Public interface IAsyncUpgradeQueueItem For internal use only. Represents a pending (queued) execution of an asynchronous upgrade action.
Public interface IAuditDefinition Represents a definition that specifies audit-event parameters. Audit events are set on a per-class basis: use this interface to configure a ISubscribableClassDefinition object or subobject for auditing. Create an IAuditDefinition object for each event that you want to audit for the class.

To create a IAuditDefinition object, call the createInstance method on the Factory.AuditDefinition class. Once created, set its properties, which define the event to be audited and other parameters.

For each IAuditDefinition object that you create, add it to a IAuditDefinitionList collection, then set the collection on the ISubscribableClassDefinition object.

To retrieve IAuditDefinition objects, get the IAuditDefinitionList collection and iterate it.

Public interface ICenteraFixedContentDevice Represents the description of an EMC Centera fixed content device.
Public interface ICenteraSiteSettings Represents the configuration settings that can be overridden for the EMC Centera fixed content devices on the specified site. For each setting that can be overridden, the CenteraSiteSettings object contains a property that, if populated, will override the corresponding property of the same name on the CenteraFixedContentDevice object.
Public interface ICFSImportAgentConfiguration Configures the importer component of Content Federation Service (CFS). The CFS importer works in conjunction with the CFS exporter to map external documents to FileNet P8 documents in a one-to-one relationship. Specifically, using data extracted from an external repository and loaded into a federator database by the exporter, the importer creates and updates FileNet P8 documents known as federated documents. (For background information on the exporter and on the relationship between the federator database, the IBM Content Integrator instance, and the external repository, see the IIICEFixedContentDevice interface.) A federated document is a FileNet P8 document created as a proxy for an external document, whereby FileNet P8 stores metadata (property values) mirroring the metadata stored in the external repository but keeps only a reference to the external stored content; the federated document accesses the external content in a transparent fashion, and thus behaves, with some limitations, like any other standard FileNet P8 document. The importer creates a new federated document to represent an external document when first importing the external document into FileNet P8. Thereafter, when subsequently re-importing the external document, the importer updates the metadata of the existing federated document.

You can associate this import configuration with a server or a group of servers. Specifically, as with all configuration objects belonging to ISubsystemConfiguration derived interfaces, an ICFSImportAgentConfiguration instance can be associated with the following types of objects (via the SubsystemConfigurations property): IServerInstance, representing one server; IVirtualServer, representing one or more servers; ISite, representing a yet larger grouping of servers and other objects based on a geographic location; and a IDomain, representing the largest possible collection of resources and services sharing the same Global Configuration Database (GCD). On startup, and periodically thereafter, the Content Engine server checks the IServerInstance object representing itself, then the IVirtualServer object representing the virtual server of which it is a part, and so on, searching for the most closely associated import configuration. At least one such configuration always exists, because the automatic creation of a default CFSImportAgentConfiguration object occurs when you first create the domain.

Some site-specific settings might override the settings configured here. For more information, see the ICFSSiteSettings interface.

The importer runs as part of the Content Engine, and one importer exists for each Content Engine instance. Each importer runs against all of the federator databases that have been defined for the domain (via GCD-stored IIICEFixedContentDevice objects); consequently, multiple importers can be operating against the same federator database. Importers process batches of import requests created in the federator database by the exporter, where each import request represents a document version series stored in the external repository. In addition to the external metadata and content, an import request has properties indicating the target document class and the target object store. An importer can process an import request for any object store within the domain. The configuration of import request processing revolves around these importer sub-components:

  • Import Dispatcher - The import dispatcher is the main sub-component of the importer; one dispatcher exists per importer. To enable or disable the dispatcher, set the DispatcherEnabled property.
  • Import Agent - The import agent periodically scans the federator database for incoming import batches, loads the batches into an in-memory federation request queue, and assigns the batches from the queue to the import workers it creates. One agent exists per federator database per Content Engine instance. Consequently, this configuration might govern the behavior of more than one dispatcher. To control the activity level of the agent, set these properties: MaxInMemoryItems and DispatcherWaitInterval.
  • Import Worker - The import worker performs the actual work of creating or updating FileNet P8 documents from the incoming external metadata and content. Each worker exists on a separate thread of execution. To control the number of workers and the distribution of work among workers, set these properties: MaxWorkerThreads, LeaseDuration, and BatchSelectionSize.
Public interface ICFSSiteSettings For a particular FileNet P8 site, configures the Content Federation Service (CFS). For information on specifying the site, and on the relationship between the FileNet P8 site and domain, see the Site property. This configuration works in conjunction with the standard CFS import configuration. For more information, see the ICFSImportAgentConfiguration interface.
Public interface IChoice Represents a single choice item in a choice list that can be assigned to a property, or represents a group node for a nested collection of choice items within a choice list. A choice item is a single possible value, or choice, in a choice list. A choice item can be of two possible types: integer or string. An integer-type choice item holds a single integer value and can be assigned only to an integer-valued property. A string-type choice item holds a single string value and can be assigned only to a string-valued property.

A Choice object is a dependently persistable object; it has no Save method and therefore cannot be independently saved. Because any given Choice object is dependent on the independently persistable com.filenet.api.admin.ChoiceList object to which it belongs, its state is not saved until you call the Save method of the ChoiceList object that owns it. For a given Choice object to belong to a com.filenet.api.admin.ChoiceList object, it must be added to the com.filenet.api.collection.ChoiceList collection that is returned by the com.filenet.api.admin.ChoiceList object's ChoiceValues property.

The type of data that a Choice object can represent is determined by the ChoiceType constant value that you specify with its ChoiceType property. This property determines whether a Choice object represents an integer-type choice item, a string-type choice item, a group node for a nested collection of integer-type choice items, or a group node for a nested collection of string-type choice items.

Localization is provided by the DisplayNames property, using the same mechanism that ClassDefinition and PropertyTemplate objects use. However, unlike those objects, the Choice object does not have a DescriptiveTexts property. To localize a Choice object, set its DisplayNames property to a LocalizedStringList object containing a collection of LocalizedString objects. Each object in this collection represents a locale-specific, user-readable display name that can be used for a Choice object; set its LocaleName property to a locale ID and its LocalizedText property to the localized text for the display name. Once you have set the DisplayNames property, the server will automatically set the value of the DisplayName property to the LocalizedText property value of the LocalizedString object in the LocalizedStringList collection that corresponds to the object store's default locale.

A Choice object's display name, or label, identifies it and is stored by its DisplayName property. You can either set the DisplayName property directly or you can set it indirectly by setting the DisplayNames property. Setting the DisplayNames property is the preferred method. You must set either a Choice object's DisplayName property or its DisplayNames property; you cannot set both. If you set the DisplayName property, the server will automatically create a LocalizedString object with its LocaleName property set to the object store's default locale and add it as a single item in the DisplayNames property's LocalizedStringList collection. If you set the DisplayName property directly, localization will be bypassed and the language of its text may not match the specified locale. For example, if you store English text (en-us) in the DisplayName property and the default locale is French (fr-fr), the DisplayNames property will return a collection containing a single LocalizedString object that specifies a French locale with English text. Note that this behavior is unique to Choice objects.

A Choice object's display name, which is always a string value, should not be confused with its value, which can be a string, an integer, or a collection of Choice objects (when a Choice object acts as a group node). A Choice object's display name is assigned with the DisplayName property, while its value is assigned using the appropriate property, depending on its type: ChoiceIntegerValue for integer-type choice items, ChoiceStringValue for string-type choice items, or ChoiceValues for group nodes. Although the server does not check the display names and values of the choice items within a given choice list for uniqueness, it is recommended that they be unique to avoid ambiguity.

To create a Choice object, call the Factory.Choice.CreateInstance method. In order to save the state of a new Choice object (when you save the com.filenet.api.collection.ChoiceList object to which it belongs), you must, at a minimum, set its ChoiceType and DisplayNames properties. The DisplayNames property can be either set directly, by setting it to a LocalizedStringList object; or set indirectly, by setting the DisplayName property. To create a list collection of Choice objects (com.filenet.api.collection.ChoiceList object), call the Factory.Choice.CreateList method.

Public interface IChoiceList Represents a choice list in an object store. Each choice list contains a list collection of Choice objects that, when associated with a property, provides a discrete set of possible values that the property can hold. By using a choice list, you can enforce restrictions on property values.

There are two types of choice lists: integer and string. A choice list's type is specified by the following TypeID constant values, which are stored in a ChoiceList object's DataType property:

  • LONG: A ChoiceList object that represents a choice list that holds integer-type Choice objects. Each Choice object in such a choice list must represent either an integer-type choice item or a group node that holds a nested collection of integer-type Choice objects. An integer-type choice list cannot contain any string-type Choice objects.
  • STRING: A ChoiceList object that represents a choice list that holds string-type Choice objects. Each Choice object in such a choice list must represent either a string-type choice item or a group node that holds a nested collection of string-type Choice objects. A string-type choice list cannot contain any integer-type Choice objects.
Note that although there are eight TypeID constants, only LONG and STRING are valid constants for a ChoiceList object's DataType property.

A ChoiceList object is independently persistable (that is, it can be saved directly using its Save method) and controls the state of any dependently persistable Choice objects that belong to it. You can access each Choice object that belong to a ChoiceList object in the com.filenet.api.collection.ChoiceList collection that is specified by its ChoiceValues property. Each Choice object in this collection represents either an individual choice item or a group node for a nested collection of Choice objects.

A choice list's display name is stored in its DisplayName property and must be unique within an object store. Unlike a Choice object, a ChoiceList object does not have a mechanism for localizing its display name.

Choice list hierarchy is specified by its HasHierarchy property. This read-only property indicates whether a given choice list has a hierarchical structure or not. If the choice list contains at least one Choice object that represents a group node, the server automatically sets this property to true.

For a choice list to be useful, it must be associated with a property. You can either associate a choice list with a property template, therefore causing it to be automatically associated with every property definition created from that property template, or you can associate a choice list with an individual property definition. To associate a choice list with a property template or a property definition, set its ChoiceList property to the com.filenet.api.admin.ChoiceList object representing the choice list.

To create a new ChoiceList object, call the Factory.ChoiceList.CreateInstance method. Set the appropriate properties and add any Choice objects to the com.filenet.api.collection.ChoiceList collection specified by its ChoiceValues property. Call the Save method to save the new object to the persistent store. For the save to be successful you must, at a minimum, set the new ChoiceList object's DisplayName and DataType properties.

Public interface IClassDefinition Represents the class definition (mutable class metadata) of non-versionable, non-subscribable classes. Subclasses of the Subscribable class are defined in SubscribableClassDefinition objects, except for the Document class and its subclasses, which are defined in DocumentClassDefinition objects, and the Event class and its subclasses, which are defined in EventClassDefinition objects. You can modify class definition metadata via its properties and property definitions throughout the life of an instantiated object. Note, however, that you cannot modify a class definition's ClassDescription property.
Public interface ICMODApplicationGroup Represents an IBM® Content Manager OnDemand (CMOD) application group that can be configured for content federation. An application group is a collection of one or more OnDemand applications with common indexing and storage management attributes.
Public interface ICMODFixedContentDevice Represents the description of an IBM® Content Manager OnDemand (CMOD) external fixed content storage device.
Public interface ICodeModule Represents a user-implemented Java event handler that's executed when a IAction-based object's events are raised. The event handler can be a Java class or JAR file, and must reside on the Content Engine.

To create a ICodeModule object, call the CreateInstance method on the Factory.CodeModule class, and then set the content elements of the Java module with the ContentElements property. Each content element must have the correct mime type property. For content elements containing a Java class, acceptable mime types are "application/java", "application/java-byte-code", and "application/x-java-class". For content elements containing a JAR, acceptable mime types are "application/java-archive", "application/x-compressed", "application/x-zip-compressed", "application/zip", and "multipart/x-zip".

Note:

      The content elements that you set on a ICodeModule object must be of type IContentTransfer, not IContentReference. If you attempt to save a ICodeModule object with a IContentReference type in the content element list, the object will throw an EVENT_CM_CONTENTREFERENCE_NOT_ALLOWED exception.
      If you create a new version of a ICodeModule, such as by updating the event handler content, then you must set the new version to the CodeModule property of any IAction-based object for which the new ICodeModule version is intended.

To instantiate a ICodeModule object, call the GetInstance or FetchInstance method on the Factory.CodeModule class.

As an alternative to representing a Java event handler as a ICodeModule object, you could specify the Java event handler in the classpath of your application server. However, in an enterprise environment, we recommend that you check in an event handler and any supporting libraries as a code module. Code modules are automatically available when deploying the Content Engine to multiple application server instances, or moving your content metadata from one system to another. If you reference event handlers in the classpath of an application server, you must manually distribute them to new systems.

For cache configuration considerations, see the applicable code module-related properties in IServerCacheConfiguration interface.

See also the Javadocs for the following interfaces: DocumentClassifier, DocumentLifecycleActionHandler, EventActionHandler

Public interface IColumnDefinition Represents the description of a column in a Content Engine database table. A ColumnDefinition object describes a column used by a TableDefinition object. By reading the properties of these objects, you can query the values contained in a table.
Public interface IContentCacheArea Represents a file storage area that stores duplicates of the document content most frequently requested, and permits those duplicates to be accessed in lieu of the originals in order to enhance the document retrieval performance of local servers. For example, a content cache area can be shared by several servers on a LAN to minimize the number of times they need to access a main storage area on the WAN. For information on configuring a content cache for a server or group of servers, see the IContentCacheConfiguration interface.

Document content consists of the content elements associated with documents (as specified by the ContentElements property on the Document object). The cache receives new content in the following circumstances:

  • Cache miss: When the cache receives a request for a file not currently residing in the cache, the cache receives a duplicate of that file as part of the document retrieval process.
  • Content preloading: When content preloading has been enabled (via the PreloadOnCreate property), the cache receives duplicates of any new content added to the main storage area.

In both circumstances, new content can be added to the cache only when its storage capacity (as defined by the MaximumContentElements and MaximumSizeKBytes properties) exceeds the current amount of content (as indicated by the ContentElementCount and ContentElementKBytes properties). Cache content, however, can end up slightly exceeding the designated storage capacity, as statistics are managed on a delayed basis, and multiple servers can be adding content.

Cache pruning is the process of deleting the content least frequently requested from the cache. Pruning deletes three main categories of files: abandoned, expired, and old. An abandoned file is an incomplete file that has been not properly added to the cache as a result of a server failure of some sort (such as a power failure). An expired file is a file that has remained in an unaccessed state longer than the maximum-time-to-live (as specified by the MaximumTimeToLive property). An old file is a file that, compared to other files in the same directory, has been accessed less recently. Note that these categories are not mutually exclusive; an abandoned file might also be an expired file, and an expired file an old file.

Pruning considers the most recent access time for a file equivalent to its time-of-last-use. This time gets updated to the current time when the file first gets added to the cache, and also whenever the file gets retrieved, provided more than 10 minutes have elapsed since the previous time-of-last-use update. Consequently, the accuracy of the time-of-last-use for a file is within 10 minutes.

Prune actions--specific instances of pruning--operate on the cache directory by directory. For a general discussion on the advantages of this approach, see the DirectoryStructure property. For a detailed discussion on prune action behavior, see the PruneAmount property.

Prune actions get triggered in three different ways:

  • Mandatory Prune: Ensures that cache content remains under prune threshold levels. For more information, see the PruneThresholdContentElements property.
  • Periodic Prune: Ensures that expired files get deleted on a timely basis. For more information, see the MaximumTimeToLive property.
  • Sweeping: Ensures that the statistics concerning content element count (the ContentElementCount property) and content element size (the ContentElementKBytes property) remain reasonably accurate. A prune action occurs as part of this statistical update. For more information on the sweep action, see the ContentElementCount property.

Cache sweeping does not update the count of content element creations (the ContentElementsCreated property) or the count of content element deletions (the ContentElementsDeleted property). These statistics can become inaccurate over time, but can be optionally reset by clearing the cache. For more information on cache clearing, see the CacheStatus property.

Public interface IContentCacheConfiguration Defines the configuration for a content cache. This includes, in particular, the file storage area for the cache (the ContentCacheArea property).

A cache configuration can be associated with a server or with a group of servers. More specifically, a ContentCacheConfiguration instance can be associated with the following types of objects: ServerInstance, which represents one server; VirtualServer, which represents one or more servers; and Site, which represents a still yet larger grouping of servers and other objects based on a geographic location. (A cache configuration can also be associated with a Domain, but typically you would not want servers in different geographical sites to use the same cache, since the cache must be local to the server to benefit server performance.) On startup, and periodically thereafter, a Content Engine server checks the ServerInstance object representing itself, then the VirtualServer object representing the virtual server of which it is a part, and so on, searching for the most closely associated cache configuration. Referred to as the primary cache, the first cache found becomes the cache for that server. Otherwise, in the absence of any cache configuration, the server does not use a cache.

In order for a cache area to be used, at least one server must be configured to be part of the same site as the cache.

Public interface IContentConfiguration Configures the Content Management Subsystem. The Content Management Subsystem is the part of the Content Engine Object Store Service that is responsible for adding and retrieving document content to and from managed storage areas in response to client requests. The ContentConfiguration interface allows the operation of the Content Management Subsystem to be tuned for the local environment in which it is executing.

Just as it must do for all other client requests involving the creation, update, or deletion of data in an object store, the Object Store Service must also guarantee transactional integrity with respect to adding content. Guaranteeing the transactional integrity of content upload and storage is one of the primary functions of the Content Management Subsystem.

In order to make this guarantee, the process of adding content is divided into two stages: Stage one involves copying content into a temporary location on the server while stage two is primarily concerned with copying the content to its permanent location.

Stage one occurs within the context of a client initiated transaction involving content upload; for example, checking in a document. In this stage, the content associated with the object or objects participating in the transaction are copied from the client to a temporary location that is associated with the designated storage area in which the content will ultimately be stored. This temporary location may be a specially designated file system directory, sometimes referred to as the "inbound directory" or it may a table in the database. The type of temporary storage depends on the destination storage area type. Any metadata changes associated with the participating objects are also carried out at this during this stage.

At the conclusion of the first stage of the operation, the transaction must be committed in order to make the changes durable. Committing the transaction includes adding a message to the ContentQueue, when processed, that will result in the second stage of the operation to be executed. The fact that the transaction has been committed after stage one necessarily implies that the server guarantees that the second stage will be carried out - even in the event of server disruptions, power failures, etc.

It is important to note that after a transaction involving content upload has been committed, that is, after stage one has completed, the new content has functionally been added to the storage area; a user can retrieve (or perform any other legal operation) on the new content just like any other content in the storage area, despite the fact that it may actually still reside in the temporary storage location.

At the conclusion of stage one of the operation or at anytime during its execution, the transaction can also be aborted and, therefore, must be rolled back. Rolling back a transaction in simple terms means guaranteeing that any intermediate changes that occurred during the execution of the transaction will be undone so that the system is restored to the state that it was in prior to the transaction and guaranteeing that none of these changes will be visible to any other transaction while they are being cleaned up.

With respect to content upload there are two categories of changes that need to be undone: Metadata changes and content that has been copied to the temporary storage area. The cleanup of the former is handled by the normal transaction processing mechanisms provided by the Object Store Service but the latter is a special case and is managed by the Content Management Subsystem. The way it works is temporary content is flagged as "abandoned". While it is in this state it is invisible to clients and is effectively "not there" from the client's point of view. The Content Management Subsystem then periodically sweeps the temporary storage areas and deletes all abandoned content.

Many of the functions of the Content Management Subsystem described above are parameterized such that their behavior can be modified. This is the purpose of the ContentConfiguration interface: To expose those aspects of content operations that can be adjusted in order to optimize the performance of the Object Store Service within a given operational environment.

Public interface IDatabaseStorageArea Represents a storage area for content elements stored in the database.
Public interface IDirectoryConfiguration Represents the base configuration object for all security providers and holds directory configuration data. The DirectoryConfiguration object is used to configure the directory service providers that are used for authorization checks within the servers.

You can create one or more DirectoryConfiguration objects for each FileNet P8 domain. For example, if you have two Active Directory forests to be accessed by the FileNet P8 domain, you must create two Active Directory-specific DirectoryConfiguration objects--one for each forest. To create an instance of the DirectoryConfiguration class, call the type-specific CreateInstance factory method. For example, to create an instance of an Active Directory configuration object, call Factory.DirectoryConfigurationAD.CreateInstance().

Public interface IDirectoryConfigurationAD Represents the configuration object for the Active Directory security provider. You must create a configuration object for each Active Directory forest that is accessed by the FileNet P8 domain. For example, if you have two Active Directory forests to be accessed by the FileNet P8 domain, you need to create two Active Directory-specific DirectoryConfiguration objects--one for each forest. To create an instance of the DirectoryConfigurationAD class, call Factory.DirectoryConfigurationAD.CreateInstance(). The group of type-specific directory configuration objects is contained in the DirectoryConfigurationADList collection object.
Public interface IDirectoryConfigurationAdam  
Public interface IDirectoryConfigurationCA This interface is not supported. An IDirectoryConfigurationCA instance represents the configuration object for a CA eTrust security provider.
Public interface IDirectoryConfigurationIBM Represents the configuration object for an IBM Tivoli security provider. An IBM Tivoli directory server can be mapped to multiple FileNet P8 realms. Each FileNet P8 realm has a one-to-one relationship with the authentication provider. There is also a one-to-one relationship between a FileNet P8 Realm object and a DirectoryConfigurationIBM object. Therefore, you must create one DirectoryConfigurationIBM object for each authentication provider in each realm. To create an instance of the DirectoryConfigurationIBM class, call Factory.DirectoryConfigurationIBM.CreateInstance(). The group of type-specific directory configuration objects is contained in the DirectoryConfigurationIBMList collection object.
Public interface IDirectoryConfigurationNovell Represents the configuration object for a Novell eDirectory security provider. A Novell eDirectory server can be mapped to multiple FileNet P8 realms. Each FileNet P8 realm has a one-to-one relationship with the authentication provider. There is also a one-to-one relationship between a FileNet P8 Realm object and a DirectoryConfigurationNovell object. Therefore, you must create one DirectoryConfigurationNovell object for each authentication provider in each realm. To create an instance of the DirectoryConfigurationNovell class, call Factory.DirectoryConfigurationNovell.CreateInstance(). The group of type-specific directory configuration objects is contained in the DirectoryConfigurationNovellList collection object.
Public interface IDirectoryConfigurationSunOne Represents the configuration object for a SunOne security provider. A SunOne directory server can be mapped to multiple FileNet P8 realms. Each FileNet P8 realm has a one-to-one relationship with the authentication provider. There is also a one-to-one relationship between a FileNet P8 Realm object and a DirectoryConfigurationSunOne object. Therefore, you must create one DirectoryConfigurationSunOne object for each authentication provider in each realm. To create an instance of the DirectoryConfigurationSunOne class, call Factory.DirectoryConfigurationSunOne.CreateInstance(). The group of type-specific directory configuration objects is contained in the DirectoryConfigurationSunOneList collection object.
Public interface IDITARenditionEngineConnection Represents site-specific connection data for a DITA Rendition Engine that is referenced by a publishing configuration. (A DITA Rendition Engine is one that uses a DITA Open Toolkit deployment for publishing documents.)
Public interface IDocumentClassDefinition Represents the class definition (mutable class metadata) of the Document class and its subclasses. You can modify class definition metadata via its properties and property definitions throughout the life of an instantiated object. Note, however, that you cannot modify a class definition's ClassDescription property.
Public interface IDocumentClassificationQueueItem Represents a pending (queued) document auto-classification request. The QueuedObject property specifies the document that is the subject of the queued request.
Public interface IEventClassDefinition Represents the class definition (mutable class metadata) of event classes whose instances can be subscribed to or audited. To instantiate a IEventClassDefinition object, call the getInstance or fetchInstance method on the Factory.EventClassDefinition class. To use IEventClassDefinition in a subscription or for auditing, set the EventClass property on a ISubscribedEvent or IAuditDefinition object, respectively.

You can modify class definition metadata via its properties and property definitions throughout the life of an instantiated object. Note, however, that you cannot modify a class definition's ClassDescription property.

Public interface IEventQueueItem Represents a pending (queued) execution of an asynchronous event action, or an asynchronous event queue item that remains unprocessed because its retry count is zero. The IEventQueueItem interface includes properties for setting and retrieving the source object and event of the pending event action.

To instantiate a IEventQueueItem object, call the getInstance or fetchInstance method on the Factory.EventQueueItem class.

Public interface IFileStorageArea Represents a storage area for content elements stored in the file system.
Public interface IFixedContentDevice Represents the base, abstract class for all classes relating to fixed content devices. A fixed content device has the following characteristics:
  • Content stored on the device may be accessed via a proprietary API, instead of the file system API.
  • The repository can be write-once, not allowing content to be changed.
  • The repository can be write-once, not allowing content to be changed or deleted.
  • The repository can support a retention period for content. The content cannot be deleted until that period has expired.
  • Read/write access to the repository may be significantly slower than access to a traditional file system.
  • The fixed content device may limit the number of concurrent connections.
Public interface IFixedStorageArea Represents a storage area for content elements stored in a fixed content device.
Public interface IGenericFixedContentDevice Represents the description of a generic fixed content device. The GenericFixedContentDevice object provides an extensible mechanism for implementing interfaces to fixed content devices not currently supported by FileNet. The ConfigurationParameters property provides the set of parameters that will be passed to a custom implementation of a fixed content provider used to connect to the fixed content device. Note that there is no fixed format for the ConfigurationParameters property (other than, it must be a string that the custom implementation of the fixed content provider can understand and parse). This object is for future use only and is not currently supported by FileNet.
Public interface IIICEFixedContentDevice Represents an external fixed content device accessible via an instance of IBM Content Integrator (formerly known as Information Integrator Content Edition or IICE). This representation serves a two-fold purpose: to identify and describe the external device, and to configure the behavior of the Content Federation Service (CFS) with respect to that device. CFS uses metadata from the external device to create and update FileNet P8 federated documents. (For information on content federation, and on the CFS import process in particular, see the ICFSImportAgentConfiguration interface.)

As a content device description, this interface ties together these main entities:

  • Federator database - This database acts as a transmission medium between the CFS exporter that pulls metadata from the external device and the CFS importer that creates and updates FileNet P8 documents using the metadata. To specify the database instance to use, set these properties: FederationJNDIDataSource and FederationJNDIXADataSource.
  • External device/repository - The external device can be a Content Services repository or any other type of repository supported by CFS. To specify the external repository to use and to allow CFS to access it, set these properties: SourceRepositoryName, CFSUserName, and CFSPassword properties.

As a means for configuring the behavior of CFS with respect to the external device, this interface can affect FileNet P8 document updates. CFS periodically pulls metadata and content from the external repository to keep FileNet P8 documents in sync with any changes made to the corresponding external documents. To control how CFS performs these periodic updates, set the FederationUpdateHasPriority property.

Public interface IImageServicesClassDescription Represents the description of an Image Services document class.
Public interface IImageServicesImportAgentConfiguration Represents configuration data for an Image Services import operation.
Public interface IImageServicesPropertyDescription Represents the description of an Image Services document class property.
Public interface IImageServicesSiteSettings Represents the configuration settings that can be overridden for the Image Services fixed content devices on the specified site. For each setting that can be overridden, the ImageServicesSiteSettings object contains a property that, if populated, will override the corresponding property of the same name on the IMFixedContentDevice object.
Public interface IIMFixedContentDevice Represents the description of a FileNet Image Services fixed content device.
Public interface IIndexArea Represents the disk storage location and data necessary to perform full-text indexing for content-based retrieval.

A single index area holds data for only one object store, using one file system directory. Spreading the indexing information across multiple file systems requires the use of multiple index areas.

The ResourceStatus property is set to "full" by the server when the number of collections is equal to VerityIndexArea.MaxCollections (no more VerityCollections can be created in this IndexArea). A replacement IndexArea (having a status of "standby" will be set to "open". If the status of an IndexArea is not "open", no new Verity collections will be created in the IndexArea. However, Verity collections in the IndexArea will be searched during queries, regardless of status.

Public interface IIndexJob Initiates and tracks the status of a full text indexing operation. IndexJob is used to rebuild the full text index in the event that it becomes corrupted, or a configuration change requires that the full text index be rebuilt. The following types of indexing scenarios are supported:

All currently indexed data is available while indexing is in progress, but some queries will get duplicate matches from full text searches, due to matches in both the old and the new index data. When the IndexJob operation completes, old copies of the data are removed (duplicate matches will no longer occur).

Most index jobs require sweeping the database looking for collections or classes to be indexed. This sweep requires a table scan on the database (taking a considerable length of time on a large table), even if the amount of data to be indexed is minimal. The database table scans are performed once for all classes to be indexed in a table, and once for all collections to be indexed in a table. To minimize the number of table scans required, we recommend you put all classes or collections to be indexed for the same table into a single IndexJob operation.

Public interface IIndexJobClassItem Identifies the class to be full text indexed. When a property or class is enabled or disabled for indexing, objects with newly enabled properties/classes need to be indexed, and objects with newly disabled properties/classes need to be removed from the index. The specified class can be any base class (such as, Document or Folder), or any of its subclasses, that support indexing. All instances of the specified class are indexed.

Warning: Do not change the CBREnabled status of a class or property while an IndexJob operation is running on that class. Doing so will cause unpredictable results. Instead, abort any index job running on a class before changing the configuration, then resubmit the index job for that class.

If the class selected to index is a base class (Versionable, Document, Annotation, Folder, or CustomObject), new VerityCollection objects are created to hold the new indexing information. When this index operation completes, the old collections that previously held the indexing information are deleted. Because deleting the indexing information is not done on an individual object basis, and is instead done by deleting all relevant Verity collections, indexing a base class is somewhat faster than indexing a subclass of the base class.

Note: For indexing purposes, the Document class is also considered to be a base class, because the Document class is the only subclass of the Versionable class, and no instances of the Versionable class can be created.

For Document or Annotation objects created using a FileNet P8 3.5.x installation: If the CBREnabled status is changed to disabled for a class that had either Document or Annotation objects that were indexed, the index job to remove the indexing information should be run before any documents or annotations are deleted or modified (the content elements removed). If this cannot be accomplished, the Document and/or Annotation class and all subclasses of these classes should be reindexed.

Public interface IIndexJobCollectionItem Identifies a Verity collection to be full text indexed. When the indexing data for one or more Verity collections becomes corrupted or lost (due to a storage device failure), the collection needs to be reindexed. This operation deletes the current indexing data, and creates new full text index data to replace it.

Warning: Do not use collection indexing to address a change in the CBREnabled status on a class or property. Only the existing data in the collection will be submitted to be indexed (even if all collections of an object store are selected). Any classes newly enabled/disabled for indexing will not be reindexed because instances of these classes may not be in the existing collections.

Public interface IIndexJobItem Indicates a particular item that is being full text indexed.
Public interface IIndexJobSingleItem Identifies an object to be full text indexed. When the original index attempt results in an indexing failure for a single object (such as a Document or Annotation object), or some aspect of the configuration (such as a Verity style file) needs to be changed, the affected object can be reindexed. Performing this operation on an object whose class is CBR enabled attempts to reindex the object. Performing this operation on an object whose class is not CBR enabled attempts to delete the object from any existing indexes.
Public interface IIsolatedRegion Contains the connection information necessary to access the Process Engine isolated region. This information is persisted in the GCD (Global Configuration Data).

An isolated region represents a logical subdivision of the Process Engine database. Each isolated region is referenced by one or more Process Engine connection points (PEConnectionPoint instances). The set of isolated regions defined is reflected in the Domain.IsolatedRegions property.

PEConnectionPointDomain
Public interface ILocalizedString Provides a means of support for locale-specific display names and descriptive text used by a class definition or property template.

You can create an instance of a LocalizedString object by calling the CreateInstance method on the Factory.LocalizedString class.

Public interface IPEConnectionPoint Routes Process Engine requests to an isolated region (IsolatedRegion instance). This information is persisted in the GCD (Global Configuration Data). Multiple PEConnectionPoint instances can reference the same isolated region. The PEConnectionPoint allows individual applications to use an arbitrary, application-specific name to refer to an isolated region. The set of connection points defined is reflected in the Domain.PEConnectionPoints property. IsolatedRegionDomain
Public interface IPropertyDefinition Represents the base class for all property definition classes. A property definition is created from a property template and holds mutable property metadata. Each property definition class corresponds to a specific property data type (for example, PropertyDefinitionBinary defines a property that returns a binary value, PropertyDefinitionBoolean defines a property that returns a Boolean value, and so on). When a property definition is added to a class definition's PropertyDefinitions collection, a user-defined property is added to that class.
Public interface IPropertyDefinitionBinary Represents the definition of a property that holds a binary value. A PropertyDefinitionBinary object is created from a PropertyTemplateBinary object and contains mutable property metadata that you can customize. When a PropertyDefinitionBinary object is added to a class definition's PropertyDefinitions collection, a user-defined property is created in that class.
Public interface IPropertyDefinitionBoolean Represents the definition of a property that holds a Boolean value. A PropertyDefinitionBoolean object is created from a PropertyTemplateBoolean object and contains mutable property metadata that you can customize. When a PropertyDefinitionBoolean object is added to a class definition's PropertyDefinitions collection, a user-defined property is created in that class.
Public interface IPropertyDefinitionDateTime Represents the definition of a property that holds a DateTime value. A PropertyDefinitionDateTime object is created from a PropertyTemplateDateTime object and contains mutable property metadata that you can customize. When a PropertyDefinitionDateTime object is added to a class definition's PropertyDefinitions collection, a user-defined property is created in that class.
Public interface IPropertyDefinitionFloat64 Represents the definition of a property that holds a Double (Float64) value. A PropertyDefinitionFloat64 object is created from a PropertyTemplateFloat64 object and contains mutable property metadata that you can customize. When a PropertyDefinitionFloat64 object is added to a class definition's PropertyDefinitions collection, a user-defined property is created in that class.
Public interface IPropertyDefinitionId Represents the definition of a property that holds a GUID string value. A PropertyDefinitionId object is created from a PropertyTemplateId object and contains mutable property metadata that you can customize. When a PropertyDefinitionId object is added to a class definition's PropertyDefinitions collection, a user-defined property is created in that class.
Public interface IPropertyDefinitionInteger32 Represents the definition of a property that holds an integer value. A PropertyDefinitionInteger32 object is created from a PropertyTemplateInteger32 object and contains mutable property metadata that you can customize. When a PropertyDefinitionInteger32 object is added to a class definition's PropertyDefinitions collection, a user-defined property is created in that class.
Public interface IPropertyDefinitionObject Represents the definition of a property that holds a Content Engine object value. A PropertyDefinitionObject object is created from a PropertyTemplateObject object and contains mutable metadata that you can customize. When a PropertyDefinitionObject object is added to a class definition's PropertyDefinitions collection, a user-defined property is created in that class.
Public interface IPropertyDefinitionString Represents the definition of a property that holds a string value. A PropertyDefinitionString object is created from a PropertyTemplateString object and contains mutable property metadata that you can customize. When a PropertyDefinitionString object is added to a class definition's PropertyDefinitions collection, a user-defined property is created in that class.
Public interface IPropertyTemplate Represents the base class for all property template classes. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
Public interface IPropertyTemplateBinary Represents a property template for creating PropertyDefinitionBinary objects, which you can add to class definitions to create user-defined properties for holding binary values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
Public interface IPropertyTemplateBoolean Represents a property template for creating PropertyDefinitionBoolean objects, which you can add to class definitions to create user-defined properties for holding Boolean values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
Public interface IPropertyTemplateDateTime Represents a property template for creating PropertyDefinitionDateTime objects, which you can add to class definitions to create user-defined properties for holding DateTime values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
Public interface IPropertyTemplateFloat64 Represents a property template for creating PropertyDefinitionFloat64 objects, which you can add to class definitions to create user-defined properties for holding Double (Float64) values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
Public interface IPropertyTemplateId Represents a property template for creating PropertyDefinitionId objects, which you can add to class definitions to create user-defined properties for holding GUID string values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
Public interface IPropertyTemplateInteger32 Represents a property template for creating PropertyDefinitionInteger32 objects, which you can add to class definitions to create user-defined properties for holding integer values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
Public interface IPropertyTemplateObject Represents a property template for creating PropertyDefinitionObject objects, which you can add to class definitions to create user-defined properties for holding Content Engine object values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
Public interface IPropertyTemplateString Represents a property template for creating PropertyDefinitionString objects, which you can add to class definitions to create user-defined properties for holding string values. A property template is a global template that enables you to create one or more property definitions for a given data type with the same set of property values.
Public interface IPublishingConfiguration References the configuration data for a publishing operation. This class allows admininistrative clients to set or access publishing-related configuration settings. A PublishingConfiguration object can be assigned to objects of the server hierarchy (Domain, Site, VirtualServer, and ServerInstance), and is persisted in the GCD.
Public interface IQueueItem Is the base class for all queue-related classes. Queue-related classes represent a pending (queued) execution of an asynchronous action on a target object. For example, a document may have a pending document classification action.

You cannot create a new instance of IQueueItem, but you can call GetInstance or FetchInstance on Factory.QueueItem to retrieve an instance of this subclassable class.

Public interface IRenditionEngineConnection Represents site-specific connection data for a Rendition Engine that is referenced by a publishing configuration.
Public interface IReplicableClassDefinition Represents the class definition (mutable class metadata) of classes of which an object instance can be replicated.
Public interface IReplicationConfiguration Represents configuration settings for the replication components of a server.
Public interface ISecurityPropagationQueueItem Represents a pending (queued) execution of an asynchronous security propagation action on a target object. Security propagation means the security assigned to a parent object will be inherited by its child objects.

You cannot create a new instance of ISecurityPropagationQueueItem, but you can retrieve a persisted object by calling FetchInstance or GetInstance on Factory.SecurityPropagationQueueItem.

Public interface IServerCacheConfiguration Defines configuration options for all server caches that do not have object store-specific characteristics. The options apply to the following caches: code module cache, GCD cache, marking set cache, metadata cache, subject cache, and user token cache. Options include a time-to-live (TTL) value for managing cache entry residency and a value that, when exceeded, triggers cache refresh activity on a least-recently-used basis. (Object store-related cache options, such as folder cache TTL and object security cache attributes, are set at the object store level.)

The ServerCacheConfiguration object is contained in the SubsystemConfigurationList property of the server hierarchy objects (Domain, Site, Virtual Server, and ServerInstance). To access a ServerCacheConfiguration object, call Get_SubsystemConfigurations to retrieve the SubsystemConfigurationList from the "host" independent object, then iterate the returned list.

To create a new instance, call Factory.ServerCacheConfiguration.CreateInstance and add the new object to the SubsystemConfigurationList of the appropriate server hierarchy object. (Note: The SubsystemConfigurationList of the Domain object cannot be modified. To update its ServerCacheConfiguration object, locate the pre-existing object in the list and update it.) The created object is a dependent object and is only persisted when its parent object (the independently persistable object that references it) is persisted.

The ServerCacheConfiguration object is associated with a Domain, Site, Virtual Server, or ServerInstance object. The values of the cache configuration properties are used while the FileNet P8 system is running and override the default values defined at installation time.

Public interface IServerInstance Represents a single instance of a Java Virtual Machine (JVM) running in an application server. One or more logically connected server instances working together constitute a virtual server. One or more virtual servers make up a site within a FileNet P8 domain.

ServerInstance objects are created dynamically during system initialization and startup based on the configured topology of the application server or via specific system properties. They cannot be created via the API. You can retrieve a persisted ServerInstance object by calling GetInstance or FetchInstance on the Factory.ServerInstance class.

Public interface ISite Identifies a geographical area within a FileNet P8 domain. A domain can have one or more configured sites. Each site is identified by a unique name and has associated servers and resources (such as object stores, index areas, storage areas, and content caches). Associated resource objects in the same geographical area have the same Site property.

When a Content Engine server in a geographically distributed environment processes a user request, it determines what resources it will need to process the request, and makes use of the site information in these resources to determine how best to process the request. The site information will determine whether or not content retrievals and uploads are processed through a content cache, and whether or not the request will be forwarded to a server in another site, closer to the resources required to process the request.

When the Content Engine server is initialized and the GCD created, a factory-generated instance of the Site class, called "Initial Site," is created and referenced by the Domain.DefaultSite property. As Virtual Servers, Server Instances, and resources (object stores, storage areas, etc.) are added to the domain, they are assigned to the DefaultSite, unless a different site is explicitly specified. A user with system administrator privileges can change the Domain.DefaultSite to a different default site, if desired.

For more information about request forwarding, see "Request Forwarding Concepts" in the Content Engine Administration documentation.

To create a new instance of this class, call Factory.Site.CreateInstance.

Public interface ISiteSettings Represents an abstract, dependent object that provides site-specific, configuration value overrides. For each fixed content device type with settings that can be overridden, a corresponding subclass of SiteSettings is defined with properties that, if populated, will override the corresponding properties of the same name on the fixed content device object.
Public interface ISnapLockFixedContentDevice Represents the description of a NetApp SnapLock fixed content device.
Public interface IStorageArea Represents the physical storage location where content will be stored. This base, abstract class has three concrete subclasses: DatabaseStorageArea, FileStorageArea, and FixedStorageArea. A FixedStorageArea object is associated with a FixedContentDevice object when it is created.

The concrete classes are customizable. This means that you can add custom properties to them (and to the base class) and create custom subclasses. By customizing the concrete classes, you can add custom criteria for selecting storage areas via a StoragePolicy.

Public interface IStoragePolicy Represents a subset of available storage areas that are deemed equivalent based on common, user-specified criteria. If a Document or Annotation object is set to use this StoragePolicy, the Content Engine will assign a storage area from this subset (pseudo-randomly, to balance load).
Public interface ISubscribableClassDefinition Represents the class definition (mutable class metadata) of classes whose instances can be the target of a subscription and can be audited. SubscribableClassDefinition objects hold the class definitions for all subclasses of the Subscribable class except for the Document class and its subclasses, whose class definitions are held by DocumentClassDefinition objects. You can modify class definition metadata via its properties and property definitions throughout the life of an instantiated object. Note, however, that you cannot modify a class definition's ClassDescription property.
Public interface ISubsystemConfiguration Represents a configuration object related to a particular subsystem or functional area that can be configured relative to a server hierarchy. This interface is the superclass for configuration objects. For each object in the hierarchy, there are a number of associated configuration objects. Each of these configuration objects has one or more attributes defining various configuration options for a particular subsystem area (such as content cache, server caching, trace logging, and so on).

All of the configuration objects available on the objects of the server hierarchy (Domain, Site, VirtualServer, and ServerInstance) are represented as a collection of dependent objects (SubsystemConfigurationList). To access a SubsystemConfiguration object, retrieve the SubsystemConfigurations property from the "host" independent object.

Public interface ITableDefinition Represents the description of a Content Engine database table. All the tables used by the Content Engine database have corresponding TableDefinition objects that are accessible using the TableDefinitions property of an ObjectStore object.

You can also access a TableDefinition object as follows:

  • Through the TableDefinition property of a ClassDefinition, DocumentClassDefinition, SubscribableClassDefinition, or VersionableClassDefinition object. This type of TableDefinition object maps to a database table that contains information about a specific class.
  • Through the TableDefinition property of a property definition object (such as, PropertyDefinitionBinary or PropertyDefinitionBoolean). This type of TableDefinition object maps to a Content Engine database table that contains information about a specific queryable property.
Public interface ITraceLoggingConfiguration Configures and enables trace logging on the Content Engine host for the supported subsystems. Each of the supported subsystems is a property on this class, enabling trace logging to be configured per subsystem. Configuring trace logging for a subsystem applies the trace logging settings to all classes in that subsystem. The TraceFlag constant class contains the trace log settings available. These settings can be ORed together to apply multiple settings to a subsystem. The TraceLoggingEnabled property on this (TraceLoggingConfiguration) class enables or disables trace logging for all of the configured subsystems. Use the AppenderNames property to specify the output destination classes for the trace logs.

Trace logging is implemented using the Apache log4j package (org.apache.log4j).

Public interface IUpgradeAddOn Specifies how to upgrade a set of existing add-ons to a new set of add-ons. An UpgradeAddOn object has the following characteristics:
  • It has import data, a pre-import script, and a post-import script, and is installed using the same API method (ObjectStore.InstallAddOn) as a normal add-on.
  • It identifies the old add-on version(s) (FromVersions property) and the new add-on version(s) (ToVersions property).
  • When an add-on has been successfully upgraded, the older version's AddOnInstallationRecord object is replaced with an installation record for the newer version.
  • It can upgrade one or more add-ons of older versions to one or more add-ons of newer versions via a single UpgradeAddOn object. For example, when an UpgradeAddOn object with a FromVersions value of [A1, A2, A3] and a ToVersions value of [A4, A5] is installed on an object store, the AddOnInstallationRecord objects for A1, A2, and A3 are removed and replaced with AddOnInstallationRecord objects for A4 and A5.
Public interface IVerityCollection Identifies the full text indexing information used for a particular base class and all of its subclasses. A VerityCollection is associated with only one IndexArea, and the full text information is stored in a file system directory identified by the VerityIndexArea.RootDirectoryPath property.

For each VerityCollection object in the Content Engine database, there is a corresponding collection maintained by the Verity software that actually holds the full text index data. The name of this collection is identified in the VerityCollection.CollectionName property.

VerityCollection objects are automatically created by the server when needed, and do not need to be created by a client application. When full text indexing is available, and the first instance of a class is created or modified, the server looks for an existing VerityCollection associated with the appropriate base class, and will use this VerityCollection. If a VerityCollection is not found, a new VerityCollection is created, along with the corresponding collection maintained by the Verity software.

An application can set the ResourceStatus property to "closed" if a problem occurs with writing data to a particular VerityCollection, or to "unavailable" if the collection is expected to be made available again eventually.

The ResourceStatus property is set to "full" by the server when the number of rows in the collection is greater than VerityServerConfiguration.MaxRowsPerCollection (no new data will be written to the collection). Whenever a collection is needed for writing full text information, the collection is selected from the list of eligible "open" collections. If no open collection exists, then a collection with a status of "standby" is selected, and that collection’s status is changed to "open".

New indexing information is written only to collections having a status of "open". However, all collections, regardless of their status, are searched when queries are performed. To prevent a collection from being searched, the associated VerityCollection object must be deleted.

Public interface IVerityDomainConfiguration Contains the Verity configuration properties that are common to all servers in a domain. Only one VerityDomainConfiguration object can exist per domain (attempts to create multiple instances of a VerityDomainConfiguration object will throw an exception). The Factory.VerityDomainConfiguration.FetchInstance method does not require an Id to fetch the VerityDomainConfiguration object.

The only two properties that must be set in VerityDomainConfiguration for full text indexing to be operational are the VerityAdminMasterServerPort and VerityAdminMasterServerHostname properties. The UserName, UserPassword, UserDomain, and UserGroup properties must all be set if security is to be enabled.

Note: The VerityServerConfiguration object contains Verity configuration properties that can be different for each server in the domain.

Public interface IVerityIndexArea Contains information about an index area that is specific to the Verity content-based retrieval engine. The ObjectStore.CBRLocale property must be set before creating an instance of this class.

The RootDirectoryPath property identifies the directory used to store full text indexing information.

Public interface IVerityServerConfiguration Contains the Verity configuration data (properties) for a server instance. This configuration data can differ from one server to the next. A VerityServerConfiguration object is contained in the SubsystemsConfiguration property of Domain, Site, VirtualServer, and ServerInstance objects. The VerityServerConfiguration object used is the first occurrence found by searching (in this order) the ServerInstance instance, the VirtualServer instance, the Site instance, and the Domain instance.

None of the properties on this object must be set or changed to enable full text indexing. This object is used only to address performance issues.

Public interface IVersionableClassDefinition Represents the parent of the DocumentClassDefinition class, which holds the class definition of a Document class and its subclasses.
Public interface IVirtualServer  
Public interface IXMLPropertyMappingScript Represents the definition of a Document subclass for defining XML property mapping scripts. The Content Engine XML Classifier uses XML property mapping scripts to populate document object properties with values based on data extracted from an XML document’s content. Administrators build mapping scripts that associate XML tags in the incoming document to properties, thus enabling the automatic classification of any XML document. An XMLPropertyMappingScript object, in addition to having all of the capabilities of a Document object, provides a container for user-authored XSL scripts for transforming XML documents of a specified type. The script contains instructions for extracting content from source XML documents of the type identified by the XMLDocumentType property in order to map it onto property values for the properties associated with the target document class identified by the TargetClass property.