All Classes and Interfaces
Class
Description
Defines a base class for implementing a
PrefilteredAdaptationFilter.Defines the permission to see and modify a resource.
Specifies a programmatic access rule.
Wraps another rule to return a maximum access level of read-only.
Specifies a programmatic access rule invoked only when a record is created.
Provides the context of the record creation
for which the access rule is being called.
Action that can be triggered by the end user.
Defines whether and how an action must be displayed in a toolbar or a menu.
Defines the permissions for whether or not a user can execute an action.
Defines permission rules for workflow administration and management.
This interface is used as the context for
ActionPermissionsOnWorkflow execution.Allows to define the activation scope and the activation rules of a user service,
namely where and when this service is available and can be executed.
Provides a context to define the activation scope and permission rules for
a user service being declared on an association level.
Provides a context to define the activation scope and permission rules for
a user service being declared on an associated record level.
Provides a context to define the activation scope and permission rules for
a user service being declared on a dataset level.
Provides a context to define the activation scope and permission rules for
a user service being declared on a dataspace level.
Provides a context to define the activation scope and permission rules for
a user service being declared on a hierarchy level.
Provides a context to define the activation scope and permission rules for
a user service being declared on a hierarchy node level.
Provides a context to define the activation scope and permission rules for
a user service being declared on a record level.
Provides a context to define the activation scope and permission rules for
a user service being declared on a table level.
Provides common methods for activation contexts related to datasets.
Provides common methods for activation contexts based on a set of schema nodes.
Provides a read-only access facade to data values in EBX®.
This abstract class is the superclass of unchecked exceptions thrown when an
dataset has an inconsistency.
Defines a specific filter over records.
Represents a dataspace or a snapshot in a repository.
Uniquely identifies a dataset or a record in a given dataspace or snapshot.
Uniquely identifies a dataset in a given dataspace or snapshot.
An instance of this class holds the records of a table node, declared as
osd:table in the data model.Iterator for optimization.
Specifies an optimization that refactors common values in a dataset tree.
Specifies an optimization by removing duplicates in a dataset tree.
Defines a specific internal value for inheritance.
Provides an execution context for handling post-dataset creation operations.
Provides a context for executing post-record creation operations.
Provides an execution context for handling post-dataset deletion operations.
Provides a context for executing post-record deletion operations.
Provides an execution context for handling post-dataset duplication operations.
Provides a context for executing operations after modifying dataset fields.
Provides a context for executing post-record modification operations.
Annotation used to allow anonymous access on a given REST resource
Java method.
Provides methods to register specific REST Toolkit JAX-RS application components
and package scan boundaries.
This interface provides constants for JAX-RS applications configuration.
An instance of this class references an archive used to
export data from / import data to EBX® repositories.
Defines the settings of an archive export.
Defines the settings of an archive import.
Defines the strategy used for importing an archive.
Provides information on the current selection, in the context of an association.
This interface contains the information for an association link
(
osd:association property).This interface contains the information for an association
over a link table (
osd:association/linkTable property).This interface contains the information for an association
that is the inverse of a foreign key
(
osd:association/tableRefInverse property).This interface contains the information for an association
that is over an XPath predicate
(
osd:association/xpathLink property).Provides information on the currently selected associated record.
Provides information on the association context of the current selection.
Annotation used to apply a specified
AuthorizationRule on
REST resource Java methods.Context providing useful information for checking authorization
on REST resources.
Defines the authorization for whether or not a user can access a REST resource.
A rule restricting access to the requested REST resource.
This interface describes a batch that can be executed in a "serverless" environment or a JEE container.
This class is used to launch
Batch.This interface is used to define the schema associated with a
non-persistent bean object (as opposed to a record or a dataset).
This runtime exception is thrown by some methods related to the dynamic beans schema definition.
This interface allows setting properties of a data model element.
This interface allows setting properties of a bean facet.
This interface allows setting the properties of a dataset constraint
facet.
This interface allows setting the properties of a dataspace constraint
facet.
This interface allows setting the properties of a foreign key facet.
Provides an execution context to handle pre-dataset creation operations.
Provides a context for executing pre-record creation operations.
Provides an execution context for handling pre-dataset deletion operations.
Provides a context for executing pre-record deletion operations.
Provides a context for executing operations before modifying dataset fields.
Provides a context for executing pre-record modification operations.
Provides a context for executing pre-transaction cancellation operations.
Provides a context for executing pre-transaction commit operations.
Identifies a dataspace in a repository.
This interface specifies the HTTP built-in query parameters
of the REST Toolkit.
Built-in trigger to start a workflow and initialize its context.
Represents the event that launched the workflow.
Represents the definition of a business object in the context of
a data model.
Represent a relationship in the context of a business object model.
Maps each REST category and available version to their related URI builder.
This enumeration provides built-in EBX® category version services.
Provides a read-only access facade to a record related
to the main record of a business object.
Defines a filter that can be applied to a specific comparison.
Condition node; its purpose is to evaluate which fork the process must take.
This abstract class must be extended in order to define a library condition.
This interface is used as the context for
ConditionBean evaluation.This interface is used as the context for
Condition
evaluation.This interface provides constants for the built-in RESTful services.
Administration report keys, parameters and operation name.
Authentication report keys, parameters and operation name.
Constraint keys and values.
Data keys and parameters.
Dataspace keys and parameters.
Deletes report keys.
Exception handling keys.
Form-data keys and parameters
Specifies the health keys.
History keys and parameters.
Meta keys and parameters.
Pagination keys and parameters.
Procedure context keys.
Selector keys and parameters.
Validation report keys.
Specifies a constraint that may be contextual and dynamic.
Provides methods for setting up a constraint in the context of its data model.
Provides methods for setting up a constraint on a table in the context of its data model.
Specifies an enumeration constraint that can be contextual and dynamic.
Deprecated.
Defines a verification for values that are mandatory under certain circumstances.
Specifies a constraint that is able to perform the validation
of an entire table.
Defines a record-level check, to be performed in addition to table-level checks.
Thrown to indicate that an insert, an update or a delete is not valid
with respect to a blocking constraint.
Provides a facade to a table record in EBX®.
Provides a facade to automatically parse a part of the request body
that may represent a table record.
Provides a facade to automatically serialize an
Adaptation,
that corresponds to a table record,
into a JSON response body.This exception is thrown whenever a conversion problem occurs.
This class specifies the properties of a work item to be created.
The broadcast handler contains the information used in the broadcast distributed transaction.
Global status of the snapshot broadcast operation.
Deprecated.
Since 5.4.2, this method has been replaced by
D3NodeAsMaster.Represents the external view of the D3 engine and offers common administrative functionalities.
Represents the external view of the D3 engine and offers primary administrative functionalities.
Represents the external view of the D3 engine and offers replica administrative functionalities.
Context having specific repository privileges to set up a D3 replica node,
during EBX® module registration.
Factory for creating a D3 engine depending on the node type chosen (primary or replica), which offers D3
administrative functionalities.
Provides a context for executing post-broadcast operations.
Provides a context for executing pre-broadcast operations.
Common super interface that provides an execution context for D3 broadcast triggers.
Specifies methods that are automatically invoked when receiving broadcast from the
D3 primary node.
D3 replica node information.
Represents the state of the replica repository.
This interface allows interacting with the name
of columns in the database.
The data context is a container for variables which must be kept
during the whole process.
The data context is a container for variables which must be kept
during the whole process.
Holds the
business object models defined
in a data model.Provides information on the currently selected dataset.
Declarative definition of a set of dataspaces thanks to a list of include and exclude subsets.
Inclusion policies for the children of a current dataset in a current subset.
This interface defines a filter to accept or reject datasets in
the context of a field of type
SchemaTypeName.OSD_DATASET_NAME.Provides methods for filtering datasets in the context of a dataset selector.
Provides methods for setting up a dataset filter in the context of its data model.
Provides information on the currently selected dataspace.
Declarative definition of a set of dataspaces thanks to a list of include and exclude subsets.
Inclusion policies for the children of a current dataspace in a current subset.
Defines all the types that a dataspace can be.
This interface defines a filter to accept or reject dataspaces in
the context of a field of type
SchemaTypeName.OSD_DATASPACE_KEY.Provides methods for filtering a dataspace in the context of a dataspace selector.
Provides methods for setting up a dataspace filter in the context of its data model.
Defines the validation report of a dataspace.
List of default view modes used to define how a group or association is displayed.
Defines the possible inheritance modes for a record.
Defines the D3 delivery modes.
Provides methods for setting dependencies in the context of
a constraint and its data model.
Main abstract class for representing differences between two entities.
Abstract class for representing differences between two datasets or two records.
Main class for comparing dataspaces and snapshots.
Represents the difference between two datasets.
Represents the difference between two records.
Represents the difference between two tables.
This class is the common entry point for performing data comparisons.
Defines the user directory used by EBX® to authenticate users
and to define users and their roles.
The default internal directory implementation that is delivered
with EBX®.
Represents a role entity that is, or can be, persisted in the default directory.
Represents a user entity that is, or can be, persisted in the default directory.
The factory for the default internal implementation of the user and roles directory that is delivered
with EBX®.
Helper class that works with
DirectoryDefault class.Factory for the user and roles directory.
An instance of this class wraps the current custom directory implementation,
so as to add pre-processing and post-verifications to the directory method implementations.
Represents the display density mode.
Defines how a toolbar action has to be displayed on launch.
Indicates that the modal should be of the specified custom size.
Indicates that the modal should be of the built-in medium size.
Indicates that the action should be displayed in the workspace.
Annotation used to document the purpose of a JAX-RS matched resource.
Defines an interface for an encryption class.
Provides a EBX® Default Directory Utility to encrypt a user password.
Provides a read-only access facade to a record
of a business object.
Provides information on the current selection.
Represents an explicit relationship defined in a resolved data model.
Defines the settings for executing an import or export to "Comma-separated values" format (CSV).
Specifies the header type of the CSV document.
Defines the settings of an export.
An annotation used to configure the extended JSON input format
for a Data Transfer Object (DTO) field of type
ContentHolder.Annotation used to configure the extended JSON output format
for a Data Transfer Object (DTO) field of type
ContentHolder.Represents a dataset that exists on the left but not on the right.
Represents the case where a dataset exists on the right but not on the left.
Represents the case where a dataset exists in the dataspace on the left
but not in the dataspace on the right.
Represents the case where a dataset exists in the dataspace on the right
but not in the dataspace on the left.
Represents the case where a record is defined in the table on the left side
not in the table on the right side.
Represents the case where a record is defined in the table on the right side
but not in the table on the left side.
Defines how to display a filtered table or record in a Web Component on first call.
Defines an interface to compute the hash of a password.
Provides information on the currently selected hierarchy.
Represents a node in a hierarchy.
Provides information on the currently selected hierarchy node.
Specifies the features of a dataspace or snapshot to be created.
Abstract superclass for dataspace and snapshot identifiers.
This runtime exception is thrown by some methods which try to change the interaction state while
the current interaction state has already been accepted or rejected.
Describes the result of an import.
Defines the settings of an import.
Defines the possible modes for an XML import.
Holds the available options for configuring the content of the
generated JSON response body.
Unchecked exception thrown when the repository or the underlying data model has changed and this
change implies that the current operation cannot be completed successfully.
Specifies the content to export from a dataset.
Specifies methods that are automatically executed when certain
operations are performed on a dataset.
Common abstract superclass that provides an execution context for dataset triggers.
This runtime exception is thrown by some methods related to interactions.
This class provides methods for implementing a user service that has been declared
as an interaction.
Defines the parameters of an interaction, either the input, output or
internal parameters.
Deprecated.
No more used since 5.2.6.
Exception thrown when a
PrimaryKey does not respect the syntax of the internal String
representation of primary keys.Thrown to indicate that a data model is not valid.
Defines a JavaBean behavior version.
Defines an action that runs a JavaScript expression.
This interface is only used to document JavaScript functions and
should not be referenced by Java code.
A JavaScript object that holds a list of messages with different severities.
Represents an HTML button generated by EBX®
using a Java
UIButtonSpec object.Instances of this class specify a call to a JavaScript function
to be performed on the client side.
Built-in LDAP directory factory for EBX®.
Class that can be extended by exceptions that return a localized error message.
Handles a lock on a dataspace.
This class provides methods for logging messages according to their severities.
This interface provides the possibility to send emails in a workflow context.
Indicates the notification type.
Provides a facade to the main record of a business object.
Thrown when an XPath expression is malformed.
Specifies the contents of a dataspace to be merged.
Specifies the contents to be merged for a dataset.
Context for the registration of a module, invoked at the initialization of
the EBX® repository.
Exception thrown when a module cannot be registered properly.
Context for the registration of dynamic resources and
module-specific initializations.
Thrown to indicate that a specified module (web application)
has not been registered in the current environment.
Ensures the EBX® module registration.
Completes module registration so as to be able to properly set up the
required environment of a D3 replica node.
Ensures the EBX® module registration from a servlet context listener.
Ensures the EBX® module registration from a HTTP servlet.
Context for registering custom search resources
in EBX®.
Context for registering the new module user services and the user service extensions
in EBX®.
This class has been replaced by
ModuleRegistrationServlet.Context providing information on a record creation.
Provides a context for preparing a transient record context upon record creation.
This class allows the transformation of data.
Context used to transform data upon export.
Represents the finest granularity of comparison, which is the difference between the
values of two nodes in a dataset or a record.
Listener interface that runs on a replica node to perform specific actions
when the replica status switches to the states 'Available' or 'Unavailable'.
Common interface providing an execution context for replica node monitoring.
A
Nomenclature is an ordered collection of NomenclatureItem instances.A
NomenclatureItem associates a value with one or more labels.A
NomenclatureItemValue is a label value in a containing Nomenclature.Identifies an object from a given context.
Annotation used to automatically create a JAX-RS application serving
OpenAPI REST resource for the underlying REST Toolkit application.
Annotation used to activate the OpenAPI documentation on the
annotated REST resource Java class.
Thrown to indicate that an operation cannot complete normally.
A path is used for locating a node in a tree structure.
Thrown when a path cannot be resolved in a data model.
Interface that provides information about a perspective.
Interface that represents the action of a perspective item.
Interface that represents a perspective action item.
An instance of this class offers methods to retrieve the perspectives defined in the current
repository.
Interface that represents an icon of a perspective menu item.
Enumerates the different types of icons.
Interface that represents a perspective item.
Interface representing an item that can have children.
Lists the different items of the perspective menu.
Interface that represents an item that can have an icon.
Interface that represents an item of a perspective section.
Interface that represents a perspective theme.
Defines an
AdaptationFilter that can be optimized using a prefilter predicate.An instance of a
PrimaryKey uniquely identifies a record in a table.This interface must be implemented in order to update data in a dataspace.
Context to execute EBX® transactions.
Represents the result of a procedure execution.
This class eases
Procedure execution through automatic pre-configuration.This interface is used as a base interface for workflow context.
Represents the permissions associated with the workflow model.
This interface is used as a generic context for workflow
execution to get information about the current process instance.
Represents a workflow and provides
related information.
Represents a comment of a workflow.
Interface that represents the history of a workflow.
Identifies a process instance.
Represents a step of a process instance.
Represents the different states of a wait task.
Prepares and launches a workflow instance.
Represents the result of a workflow instance launcher
Identifies a user profile for permission management.
This class is used by a user and roles directory to customize the profiles that a user can
select.
This class provides the ability to programmatically log a user session.
Specifications for publishing a single workflow.
Retrieves the mode of the publication.
Represents a workflow publication and provides
information about it.
Identifies a specific publication of a process definition.
An object that represents a compiled and validated SQL query.
A builder for query objects, capable of creating queries which reference
tables from multiple datasets.
Thrown if a SQL query string cannot be parsed.
This exception is thrown when a query fails because some nodes are not visible for the user.
Represents the result of a query.
Provides a read-access facade to objects in a tree structure
conforming to an underlying data model.
Interface to be implemented for read-only transactions.
Provides information on the currently selected record.
Represents the refresh policy of a
ReplicationUnit.An instance of this class specifies a relationship between nodes
in the same dataset or in another dataset.
Provides utility methods for accessing directly
from a record to the result of a relationship.
Represents a replica in a replication unit.
Represents a replica of an aggregated list
in a replica table.
Represents a replica table in a replication unit.
A replication unit is defined by the data model.
Identifies a replication unit defined in a data model.
Represents the data repository in EBX®.
Thrown when a technical problem occurs while accessing data, for example, due to unavailable resources.
Allows anonymizing records.
Provides access to a record to be anonymized, granting the
privilege to modify the value of its fields.
Provides general management information about a repository.
Identifies a repository in a persistent manner.
Defines the administrative actions for purging a repository.
Defines the status of a repository regarding the ownership of the database.
Defines a specific request on a table.
Performs paged navigation upon a request.
Represents a page over a request.
Represents the result of a
Request.Specifies sort criteria to be associated with a request.
Identifies a type of packaged resource.
Identifies a type of packaged resource.
Defines the components for a REST Toolkit JAX-RS application.
Deprecated.
replaced by
ConstantsDeprecated.
since 6.1.0.
Represents a reverse relationship in a resolved data model.
Represents a reverse relationship in a resolved data model
where the node that defines the foreign key constraint,
the selection link or the association link is in
another dataset.
Represents a reverse relationship in a resolved data model
where the node that defines the foreign key constraint,
the selection link or the association link is in
the same dataset.
Represents the result of a reverse relationship.
Represents the result of a reverse relationship in a specific dataspace.
Represents the result of a reverse relationship
where the node that defines the foreign key constraint,
the selection link or the association link is in
another dataset.
A role is a profile that is not a reference to a specific user; several users can have the same role.
Context of a scheduled task execution.
Task definition to be executed by the EBX® task scheduler.
Thrown to interrupt a
ScheduledTask.Abstract class for dynamically computing the label and description of a node in
the context of a data model.
This class provides the context used for computing
the label and description associated with a node in a data model.
Provides methods for setting up the documentation of a data model.
Defines extensions of a data model.
Context for specifying extensions of a data model.
Common interface for constraints on data types
(also known as constraining facets in XML Schema).
Represents the blocking policy defined
by a facet using the property
osd:validation/blocksCommit.This interface represents the
maxExclusive, maxInclusive,
minExclusive, and minInclusive facets associated with a node.This interface represents the
maxExclusive facet associated with a node.This interface represents the
maxInclusive facet associated with a node.This interface represents the
minExclusive facet associated with a node.This interface represents the
minInclusive facet associated with a node.This interface represents enumeration facets associated with a node.
This interface represents the
excludeSegment facet associated with a node.This interface represents the
excludeValue facet associated with a node.This interface represents the
fractionDigits facet associated with a node.This interface represents the
length facet associated with a node.This interface represents the
maxLength facet associated with a node.This interface represents the
minLength facet associated with a node.This interface declares the common methods related to the facets
length, minLength and maxLength
associated with a node.This interface corresponds to a cardinality constraint
on a mandatory field (defines both
minOccurs="1" and
maxOccurs="1").This interface represents the
resource constraint associated with a node
(osd:FacetOResource).This interface represents the
pattern facet associated with a node.This interface represents the foreign key constraint associated with a node
(
osd:tableRef).This interface represents the
totalDigits facet associated with a node.Represents the validation messages defined by a facet in a data model.
Represents the validation policy defined
by a facet using the property
osd:validation.This interface represents the inheritance properties defined in the data model
on a node defining the property
osd:inheritance.This interface contains the information for a linked node
(node that defines
osd:function linkedField="aPath" property).Identifies a data model location, which can be either based on a URL (standard notation)
or a module.
This interface contains the
paths to the nodes that
hold the metadata associated to table records.Represents an element declaration in the resolved data model.
Represents the
breadcrumb element associated with
a table, a foreign key or an association node in a resolved data model.This interface defines common services for performing
a validation task on an entity associated with a
data model node.Represents the
osd:defaultView element associated with a node in a resolved data model.This interface represents a relationship
defined in a resolved data model.
Represents the
osd:information element associated with a node in a resolved data model.Contains all the relationships held by a node in a resolved data model.
Identifies a named type definition.
Script task node, represents an automatic task during a process execution.
This abstract class must be implemented in order to define a library script task.
This interface is used as the context for
ScriptTaskBean execution.This interface is used as the context for
ScriptTask
execution.Identifies a search strategy.
The main interface to implement for a search template.
Identifies a search template.
Provides access to the declared search templates.
This interface contains the information for a selection link
(
osd:select property).Defines a user service call that can be used on a toolbar element with an action.
This interface can be implemented to dynamically figure out
whether a user service is globally disabled on a dataset and/or a dataspace.
Provides the context in which a service restriction rule is being evaluated.
This interface can be implemented to specify whether a user service
is disabled for a given dataspace.
Provides the context in which a service restriction rule is being evaluated.
Deprecated.
From release 6.0, this API is no longer supported.
Identifies a group of user services.
Identifies a user service.
Attached to a legacy user service definition, this interface
specifies the conditions under which this service can be executed.
Attached to a legacy user service definition, this interface
specifies the conditions under which this service may be executed in the context of a hierarchy.
This interface can be implemented to specify the conditions under which
a user service can be displayed and executed.
Provides the context in which a service permission rule is being evaluated.
Represents an authenticated user session, either an HTTP session or a "programmatic" session.
This interface provides EBX® information for the current REST request.
A session interaction is tightly associated to a work item to represent its running state.
Contains the report of a decision request (accept or reject).
Gives information about the specification of the interaction.
Defines a facade for checking the user's session permissions (access rights or actions) on dataspaces,
snapshots, datasets, records, and nodes (tables, ...).
This enumeration class defines the possible severity levels of user messages.
The size object is used to specify the size of a few form components.
A path is a sequence of steps.
This interface represents a list of stop words to be declared in a module.
Identifies a stop word list.
Provides the context when all launched sub-workflows have completed.
Provides the context for launching the sub-workflows of a step.
This abstract class must be extended in order to define a specific sub-workflow invocation.
This interface represents a list a synonyms to declare in a module.
Represents a pair of synonyms.
Identifies a Synonyms list.
Annotation used to reference a schema table linked to
a Data Transfer Object (DTO) field of type
ContentHolder.Provides information on the currently selected table.
Defines a custom renderer for displaying a foreign key constraint depending on the context of a node.
Provides methods for setting up a
TableRefDisplay
in the context of its data model.Defines a filter that depends on the context of a constraint.
Provides methods for setting up a
TableRefFilter
in the context of its data model.Specifies methods that are automatically executed when certain
operations are performed on a table.
Common abstract superclass that provides an execution context for table triggers.
Provides information on the currently selected table and on the current record
selection if any.
This class can be used to write JUnit tests for EBX®.
Provides information on tile view description.
Provides information on tile view Image.
Allows to define a toolbar.
Allows to define a toolbar action button.
Allows to define an action menu item.
Allows to define a toolbar button.
Defines a toolbar element on which the end user can trigger a specific action.
Allows to create a new toolbar.
Possible locations of a toolbar.
Allows to define a menu.
Allows to define a toolbar menu button.
Allows to define a group menu item.
Allows to define a menu item.
Allows to define a sub menu item.
Common abstract superclass that provides an execution context for triggers.
Provides methods for setting up a trigger in the context of its data model.
Interface for extracting the elements of a query result tuple.
Abstract class for implementing an Ajax component.
Encapsulates an HTTP response so that an Ajax component is able
to generate its part of the DHTML page.
This interface is common to all EBX® model-driven widgets based on
a single data model field.
This interface is common to all EBX® model-driven widgets based on
a single data model enumerated field.
This interface represents an item in the parent interface
UIAtomicWithEnumeration,
which corresponds to an index in the enumeration.Deprecated.
From 5.8.0, please use the new API
UICustomWidget instead.Deprecated.
To use only for backward compatibility of
UIBeanEditor implementations written
in versions 4.x.This interface provides methods for adding text to the body of a document.
This class is used to set the icon of a button.
This class can be used to set the layout of a button.
This class provides different ways to display the relief of a button.
This abstract class provides the common features for different types of buttons.
Standard button to launch a JavaScript command.
Standard toggle button that calls a JavaScript command for each change
of state.
This abstract class provides the common features for buttons that can redirect current user.
In the context of User services, specifies an HTML submit button.
Standard button to redirect user to a given URL.
This interface represents a checkbox corresponding to an index
in an enumeration.
Group of checkboxes based on an enumeration.
This interface represents a color picker which is composed of a preview box, an input and a button.
Combo box composed of a drop-down list and a text box to filter the list.
This interface offers common user interface methods to create standard
EBX® components.
Deprecated.
, @see
UICustomWidgetThis class defines all CSS classes usable for User services, UI beans and
FormPanes.All the CSS classes used to display standard icons.
For basic tables (
<table>,
<tr>, <th> and
<td> containing data).All the CSS classes used to display standard text styles.
This class defines server-side CSS utilities.
Provides information on custom view context.
Provides information on custom view key.
Provides factory methods to create
UICustomViewKeys.Base class for custom widgets.
A widget made of a combo box displaying the dataset tree and a text box for filtering.
A widget made of a combo box displaying the dataspace tree and a text box for filtering.
Date/time field.
This interface provides methods to add dependencies to resource files
in the current response context.
Simple HTML drop-down list.
In the context of a form, specifies an expand/collapse block specification.
This abstract class is the entry point for implementing a custom record form.
Allows defining the body of a custom form.
The bottom bar of a form can be composed of four buttons:
Close
Revert
Save
Save & Close
Context provided by the user interface container
that helps when defining the various parts of a custom form.
In the context of a form, specifies a group of form rows or form groups with an indentation.
A form group can have several display modes.
Allows defining the header of a custom form.
Specifies a label to display and optional additional documentation,
accessible in a pop-up.
Describes the content of a documentation pane.
In the context of a form, specifies a record node in a row.
Represents the display policy of a node.
Allows to define an HTML content.
This pane provides a table with a list of simple fields/complex groups.
This layout divides the form into a set of
tabs.This class offers a tab to have a
UIFormLabelSpec
for the title and thus can have a UIFormLabelSpec.DocumentationPane.Encapsulates an HTTP response so that a form layout is able
to generate its part of the page, including the building of
standard model-driven widgets.
Encapsulates an HTTP request so that a custom form can
provide the user input validation context.
In the context of a form, specifies a row composed of an icon, a label and a user input
area (or display area, if in read-only mode).
This class can be used to set a built-in icon at the beginning of a form row.
In the context of User services, specifies the general features of an HTML form.
This interface offers methods useful to create standard EBX® forms.
Provides information on hierarchical view.
This class is a utility for invoking
user interface components using the HTTP protocol.
Defines the appearance of the close button.
Constants for features available in dataset.
Constants for features available in record form.
Defines the scope of the user navigation, namely, the parts of the user interface that are available to the user
during the session.
Constants for features available in tables and hierarchies.
Represents the return code of a user interaction initiated by
UIHttpManagerComponent.This interface provides methods to add JavaScript in the current
response context.
Interface for displaying a record in a table or a foreign key constraint.
Provides a context for displaying a record.
Interface for presenting a hierarchy node inside a hierarchy tree.
Provides a context for displaying a hierarchy node.
Simple HTML list box, with multi-selection.
Base class for custom widgets handling whole list elements.
Password field.
This interface represents a radio button corresponding to an index in an enumeration.
Group of radio buttons based on an enumeration.
Provides a common interface for computing labels.
Defines the rendering mode of the UI.
Deprecated.
From 5.8.0, please use the new API
UICustomWidget instead.This interface defines methods to build URLs that change the entity in the current
navigation context and access various types of resources
(Web Component, Ajax component, static web resources).
Deprecated.
From 5.8.0, please use the new API
UICustomWidget instead.Deprecated.
From release 6.0, this API is no longer supported.
This interface provides methods for retrieving a user session
from a user interface component.
Base class for custom widgets handling non-list elements.
This interface represents a table component.
This class is used to define table cell styles for a UI bean editor.
Abstract class for implementing a user interface filter on a table.
Common interface for contexts used by a
UITableFilterEncapsulates an HTTP request in order to set up a filter.
Encapsulates an HTTP request in order to display a table filter.
Provides information on tabular view.
One-line or multi-line text box.
Provides information on tile view.
Provides information on custom view.
This interface is common to all EBX® model-driven widgets.
This interface defines a factory to create a custom widget.
Widget for an upload file field.
Widget factory for an upload file field.
Unchecked exception thrown when the content of a dataset is not available,
because the associated data model has errors.
Checked exception thrown when the repository is not available.
Defines a uniqueness constraint (property
xs:unique)
held by a table node in a data model.A runtime exception indicating that the request was understood and
the syntax was correct but that the server was unable to process
the contained instructions.
This class represents an uploaded file.
Provides useful methods to generate a
URI to EBX® built-in REST services.Aggregates methods to generate built-in REST services
URI
to data and history category resources.Contains methods to generate built-in REST services
URI to a dataset.Beta feature:
Contains methods to generate built-in REST services
URI to a dataspace.Contains methods to generate built-in REST services
URI to a record field
or a dataset node.Contains methods to generate built-in REST services
URI to a record.Contains methods to generate built-in REST services
URI to a table.This class provides useful methods to generate URI to EBX® packaged resources.
This class provides useful methods to generate URI specific to EBX®.
Defines an action that opens a specific URL.
Represents a list of URL query parameters.
Common abstract class for holding a text message.
Provides a localized message based on strings directly set from Java code (not
externalized).
Holds a user message that is persisted in a Java resource bundle.
Provides a message based on strings directly set from Java code (not
externalized).
Identifies a specific user.
Main interface to be implemented for a user service.
This interface provides information and utility methods useful
when processing an Ajax request.
Interface that an Ajax request callback must implement.
This interface provides methods to generate a response when processing
an Ajax request.
This interface defines methods to get the contextual information when
the user service must be created in replacement of the default record form,
for an associated object to be created or accessed.
This interface defines methods to get information on the current selected association and current
user session.
This interface defines methods to get information on the current selected association record and current
user session.
This interface defines methods to get information on the current selected association record and current
user session.
This interface defines a factory to create a
UserService replacing
the default record form in the context of an associated object to be created
or accessed.Provides methods for setting up a
UserServiceAssociationRecordFormFactory in the context of its data model.This interface allows to declare a user service.
Declares a user service that works at an
association element level.
Declares a user service that works on a
single associated record.
Declares a user service that works at the global dataset level.
Declares a user service that works at the global dataspace level.
Declares a user service that works at the
hierarchy level.
Declares a user service that works on a
single hierarchy node.
Declares a user service
that works on a single record.
Declares a user service that works at the
table level, tabular view level and/or record selection level.
This runtime exception is thrown during a user service declaration,
if it is inconsistent.
This interface provides methods to set up a user service display.
Interface that an event callback must implement.
This interface provides information and utility methods useful when
processing an event.
An object returned by an event callback should implement this interface.
This runtime exception is thrown by some methods related to user services.
Extended interface that can be implemented by a user service.
Allows to extend an existing user service.
Extended interface that can be implemented by a user service replacing a creation form.
This interface provides information and utility methods
useful when processing a GET request.
This interface defines methods to get contextual information about
the user service being invoked.
Interface that a GET request callback must implement.
This interface provides methods to generate a response when processing
an GET request.
This interface provides information and utility methods useful when initializing a
user service.
This interface defines methods to get contextual information about
the user service being invoked.
This class provides static methods to create standard outcome values
specifying what to do next.
This interface provides methods to access objects registered for the user service.
This interface provides methods to register or remove objects managed by
the user service.
This interface provides methods to access or update objects registered for
the user service.
Interface that a user service pane must implement.
This interface provides information and utility methods useful
when defining a user service pane.
This interface provides useful methods for rendering a user service pane.
Defines the permission for whether or not a user can display or execute
a user service.
This interface provides information and utility methods useful when
processing an event outcome.
Provides a context to define the common properties of a user service.
This interface allows to define a user service raw pane.
This interface provides information and utility methods useful
when defining a user service raw pane.
This interface provides useful methods for rendering a user service pane.
This interface defines methods to get contextual information when
the user service must be created in replacement of the default record form.
This interface defines methods to get information on the current selected table and current
user session.
This interface defines methods to get information on the current selected record and current
user session.
This interface defines methods to get information on the current selected record and current
user session.
This interface defines a factory to create a
UserService replacing
the default model-driven record form.Provides methods that are useful when setting up a
UserServiceRecordFormFactory in the context of a data
model.Defines an interface to provide information about a request for a user service.
This interface defines methods to build URLs that are useful for a user
service.
Deprecated.
From 6.0.0,
UserServiceDisplayConfigurator.newTabbedPane()
now returns a UserServiceTabbedPane.This interface provides information and utility methods useful when setting
up a user service display.
This interface provides information and utility methods useful
when defining objects managed by the user service.
A tab in a tabbed pane.
This layout divides the pane into a set of
tabs.This interface offers the possibility to mix in a single transaction and in any
specified order:
Record creations,
Record or dataset updates,
Custom procedure executions.
Enumeration for specifying the outcome of a transaction when the underlying data,
of the object being updated, was deleted by another thread.
This class provides methods to execute transactions from a user service.
This interface provides information and utility methods useful when
performing custom validation.
This interface provides methods for rendering a user service content.
If a user task requires custom behavior that cannot be specified declaratively
in the workflow model, this abstract class must be extended.
Defines the different strategies for work items completion.
Represents the user task mode.
Defines the resulting state of a work item.
Dedicated context to perform checks when the user clicks the 'accept' or the 'reject' button
on an interaction.
This interface is used as the context for
work items creation.Represents a user task result.
This interface is used as the context for
UserTask.getUsersForAllocation(UserTaskUsersForAllocationCollectorContext) to get
the users list for the allocation or reallocation of a work item.This interface is used as the context for
work item completion.A validation report is composed of validation items, each one
characterized by a severity and a user message.
Represents an element of a validation report.
Iterator over items contained in a validation report.
Represents the subject of a validation report item.
Represents the subject of a validation report item in the context of a dataset or record.
Represents the subject of a validation report item in the context of a table.
Defines the properties for validating a dataset, a table or a record.
Defines the refresh policy for validating a dataset, a table or a record.
Thrown to indicate when an access to a value is not possible because of some inconsistencies
in the data.
Represents a change of a terminal node value.
Represents changes applied on a record.
Common interface for accessing the content and context of a dataset or record.
This container interface enhances the validation interface with the possibility to set values that will
be automatically validated against the underlying data model.
This container interface provides the possibility of setting values on persisted or transient
content whose structure and types conform to an underlying data model.
Defines the policy for validating this content.
This container interface provides services for
performing validations on nodes containing values.
This interface represents a validation context for a record,
in the scope of a constraint on table that performs checks at the record-level.
This interface provides the services for accessing the content of a table
and for adding validation messages in the context of a validation process.
Computes a value when this value is not persisted by EBX® repository.
Provides methods for setting up a value function in the context of its data model.
Identifies a snapshot in a repository.
This abstract class must be extended to define a wait task bean.
This interface is used as the context for
resuming a wait task.This interface is used as the context for
starting a wait task.Represents the message given to resume a wait task.
Represents the result after resuming a wait task.
Indicates the reason of a resumption failure.
Defines an action that runs a Web component.
Provides a context to explicitly declare the HTTP parameters of a user service
and to make this service available in the user interfaces used to
to define a perspective action or a workflow user task.
Specifies a parameter that can be used in the HTTP invocation
of a Web component.
Context of a custom widget, containing values and
information about the context in which the widget is called.
Context provided by the user interface to create a new instance
of a custom widget.
Provides methods for setting up a widget factory in the context of its data model.
Encapsulates an HTTP request so that a custom widget can provide the user
input validation context for list custom widget.
Encapsulates an HTTP request so that a custom widget can provide the user
input validation context.
This interface offers methods that can be used to create a standard EBX® widget.
This interface offers methods that can be used to create a standard EBX® list widget.
Represents the workflow engine and
offers some administration functionalities.
Represents information about a workflow launcher activation, including details
about the launcher, associated documentation, and context variables.
This class provides utility methods for retrieving and processing information about available workflow launcher activations.
Publishes one or more workflow.
Dedicated context to handle the event "after process instance start".
Dedicated context for handling the event "after work item creation".
Defines a specific workflow trigger to be called at each main event in the life
cycle of a workflow instance.
Dedicated context for handling the event "before process instance completion".
Dedicated context for handling the event "before work item allocation".
Dedicated context for handling the event "before work item deallocation".
Dedicated context for handling the event "before work item reallocation".
Dedicated context for handling the event "before work item start".
Dedicated context for handling the event "before work item termination".
Context for handling events related to a workflow.
Context for handling events related to a workflow step.
Context for handling the event related to work item allocations.
Context for handling events related to a workflow work item in an authenticated user session.
Context for handling events related to a workflow work item.
Specifies a view in the data workflow area of the user interface.
Identifies a work item.
Builds and manipulates table record XPath expressions.
Defines an XPath predicate.
enumeration constraintis more appropriate than this interface when there are many values in the enumeration or when display must be localized.