All Classes and Interfaces
Class
Description
Implements cache functionality for the TTS service extending this class.
A base class that should be used by console command extension for better inclusion.
The
AbstractDescriptionType class is the base class for a ThingType,
a BridgeType a ChannelType or a ChannelGroupType.The
AbstractDiscoveryService provides methods which handle the DiscoveryListeners.The
AbstractDynamicDescriptionProvider provides a base implementation for dynamic description providers.Abstract implementation of the
Event interface.The
AbstractEventFactory defines an abstract implementation of the EventFactory interface.Deprecated.
Provides an exception class for openHAB that incorporates support for internationalization
Base class for internationalization mojos using openHAB XML information.
Abstract implementation of an inbox event which will be posted by the
Inbox
for added, removed and updated discovery results.AbstractItemChannelLinkRegistryEvent is an abstract class for item channel link events.
The
AbstractItemEventSubscriber defines an abstract implementation of the EventSubscriber interface
for receiving ItemStateEvents and ItemCommandEvents from the openHAB event bus.AbstractItemFileGenerator is the base class for any Item file generator.AbstractItemFileGenerator.ConfigParameter is a container for any configuration parameter defined by a name and a value.Abstract implementation of an item registry event which will be posted by the
ItemRegistry for added, removed
and updated items.Manual modifications go to
ItemsIdeModule.Manual modifications go to
ItemsRuntimeModule.AbstractLink is the abstract base class of all links.This is an abstract class for link data transfer object that is used to serialize links.
AbstractLinkRegistry is an abstract class for link based registries,
which handle AbstractLinks.AbstractManagedProvider is an abstract implementation for the ManagedProvider interface and can be
used as base class for ManagedProvider implementations.Manual modifications go to
PersistenceIdeModule.Manual modifications go to
PersistenceRuntimeModule.AbstractProvider can be used as base class for Provider implementations.Implement this class to provide a strategy for (re)establishing a lost
broker connection.
The
AbstractRegistry is an abstract implementation of the Registry interface, that can be used as
base class for Registry implementations.The
AbstractRemoteAddonService implements basic functionality of a remote add-on-serviceThis is an abstract base class for implementing icon providers that serve icons from file resources.
A human language command interpretation service.
abstract class for rule events
Manual modifications go to
RulesIdeModule.Manual modifications go to
RulesRuntimeModule.The
AbstractScriptDependencyTracker tracks dependencies between scripts and reloads dependees
It needs to be sub-classed for each ScriptEngineFactory
that wants to support dependency trackingThis is an abstract class for implementing
ScriptEngineFactorys.The
AbstractScriptFileWatcher is default implementation for watching a directory for files.Manual modifications go to
ScriptIdeModule.Manual modifications go to
ScriptRuntimeModule.The
AbstractServiceBundleTracker tracks a set of bundles (selected AbstractServiceBundleTracker.isRelevantBundle(Bundle)
and sets the
AbstractServiceBundleTracker.readyMarker when all registered bundles are activeManual modifications go to
SitemapIdeModule.Manual modifications go to
SitemapRuntimeModule.The
AbstractStorageBasedTypeProvider is the base class for the implementation of a Storage based
ThingTypeProvider, ChannelTypeProvider and ChannelGroupTypeProvider
It can be subclassed by bindings that create ThingTypes and ChannelTypes on-the-fly and need to
persist those for future thing initializationsThis is a data transfer object that is used to serialize things.
AbstractThingFileGenerator is the base class for any Thing file generator.AbstractThingFileGenerator.ConfigParameter is a container for any configuration parameter defined by a name and a value.The
AbstractThingHandlerDiscoveryService extends the AbstractDiscoveryService for thing-based
discovery services.Manual modifications go to
ThingIdeModule.Abstract implementation of a thing registry event which will be posted by a
ThingRegistry for added, removed
and updated items.Manual modifications go to
ThingRuntimeModule.The
AbstractTypedEventSubscriber is an abstract implementation of the EventSubscriber interface which
helps to subscribe to a specific event type.A non specific base class for unique identifiers.
A representation of the model object 'Abstract Unit'.
An implementation of the model object 'Abstract Unit'.
Common base class for XML based providers.
The
AbstractXmlConfigDescriptionProvider is a concrete implementation of the
ConfigDescriptionProvider
service interface.Handler to act up on changes of the access token.
This is the Access Token Response, a simple value-object that holds the result of the
from an Access Token Request, as listed in RFC 6749:
4.1.4 - Authorization Code grant - Access Token Response,
4.2.2 - Implicit Grant - Access Token Response,
4.3.3 - Resource Owner Password Credentials Grant - Access Token Response
4.4.3 - Client Credentials Grant - Access Token Response
This interface represents automation
Action modules which are the expected result of Rules execution.This class allows the easy construction of an
Action instance using the builder pattern.This is a special class loader that tries to resolve classes from available
ActionServices,
if the class cannot be resolved from the normal classpath.This is a data transfer object that is used to serialize the respective class.
This is a utility class to convert between the respective object and its DTO.
This interface should be implemented by external modules which provide functionality for processing
Action
modules.Input parameter for an action module
Input parameter wrapper for an action module
This is an utility class to convert the
Inputs of a ActionType into a list of
ConfigDescriptionParameters and to convert serialised inputs to the Java types required by the
Inputs of a ActionType.Type to distinguish annotated ActionModules
Output parameter for an action module
Output parameter wrapper for an action module
Scope definition for an action module
This interface must be implemented by services that want to contribute script actions.
This class provides common functionality for creating
Action instances by supplying their meta-information.This is a data transfer object that is used to serialize the respective class.
This is a utility class to convert between the respective object and its DTO.
Extension of the default OSGi bundle activator
Deprecated.
This class is not meant as a public API - it should only be used internally from within the framework
This class defines an add-on.
DTO for serialization of a suggested addon discovery method.
This is an
Event that is sent on add-on operations, such as installing and
uninstalling.This is an
EventFactory for creating add-on events.This is a
AddonFinder interface for classes that find add-ons that are suggested to be installed.This
AddonFinderConstants contains constants describing add-on finders available in core.Classes implementing this interface can be registered as an OSGi service in order to provide functionality for
managing add-on suggestion finders, such as installing and uninstalling them.
This OSGi service could be used to localize the add-on info using the I18N mechanism of the openHAB
framework.
The
AddonInfo class contains general information about an add-on.Java class for anonymous complex type.
DTO containing a list of
AddonInfoThe
AddonInfoProvider is a service interface providing AddonInfo objects.The
AddonInfoRegistry provides access to AddonInfo objects.DTO for serialization of a property match regular expression.
DTO for serialization of a add-on discovery parameter.
Classes implementing this interface can be registered as an OSGi service in order to provide functionality for
managing add-ons, such as listing, installing and uninstalling them.
This is a
AddonSuggestionService which discovers suggested add-ons for the user to install.This class defines an add-on type.
A representation of the model object 'Alias Configuration'.
An implementation of the model object 'Alias Configuration'.
A representation of the model object 'All Config'.
An implementation of the model object 'All Config'.
Marker interface for RuleActions
Every method in the implementation should provide annotations which are used to create the ModuleTypes
ModuleTypeProvider that collects actions for
ThingHandlersHelper methods for
AnnotatedActions ModuleTypeProviderThis
SecurityContext can be used to give anonymous users (i.e. unauthenticated requests) the "user" role.Define Area density type (basic unit is kg/m^2)
https://en.wikipedia.org/wiki/Area_density
This interface is only a container for functions that require the core type library
for its calculations.
This does a logical 'and' operation.
This calculates the numeric average over all item states of decimal type.
This calculates the number of items in the group matching the
regular expression passed in parameter
Group:Number:COUNT(".") will count all items having a string state of one character
Group:Number:COUNT("[5-9]") will count all items having a string state between 5 and 9
...
This calculates the maximum value of all item states of decimal type.
This calculates the numeric median over all item states of decimal type.
This calculates the minimum value of all item states of decimal type.
This does a logical 'nand' operation.
This does a logical 'nor' operation.
This does a logical 'or' operation.
This calculates the numeric sum over all item states of decimal type.
This does a logical 'xor' operation.
Abstract syntax tree node.
Encapsulates result of modbus read operations
Encapsulates result of modbus read operations
Encapsulates result of modbus write operations
The static methods of this class are made available as functions in the scripts.
General purpose audio exception
An audio format definition
This is an interface that is implemented by
AudioServlet and which allows
exposing audio streams through HTTP.This service provides functionality around audio services and is the central service to be used directly by others.
Definition of an audio output like headphones, a speaker or for writing to
a file / clip.
Definition of an audio output like headphones, a speaker or for writing to
a file / clip.
Definition of an audio output like headphones, a speaker or for writing to
a file / clip.
Some utility methods for sink
Some utility methods for sink
This is an audio source, which can provide a continuous live stream of audio.
A
STTEvent fired when the STTService starts hearing audio.A
STTEvent fired when the STTService stops hearing audio.Wrapper for a source of audio data.
Some general filename and extension utilities.
Some utility methods for parsing and cleaning wav files
Definition of authentication given to username after verification of credentials by authentication provider.
Base type for exceptions thrown by authentication layer.
Authentication manager is main entry point for all places which are interested in securing requests and verifying
their originator.
Realizations of this type are responsible for checking validity of various credentials and giving back authentication
which defines access scope for authenticated user or system.
This filter is responsible for parsing credentials provided with a request, and hydrating a
SecurityContext
from these credentials if they are valid.This class is a factory that creates Timer and Execution Events.
A binding's recommendation to the framework whether a state update should be automatically sent to an item if a
command was received.
This is a base class that can be used by ActionModuleHandler implementations
This is a
BaseAddonFinder abstract class for finding suggested add-ons.The
BaseBridgeHandler implements the BridgeHandler interface and adds some convenience methods for
bridges to the BaseThingHandler.This is a base class that can be used by ConditionModuleHandler implementations
The
BaseDynamicCommandDescriptionProvider provides a base implementation for the
DynamicCommandDescriptionProvider.The
BaseDynamicStateDescriptionProvider provides a base implementation for the
DynamicStateDescriptionProvider.This is a base class that can be used by any ModuleHandler implementation
This class provides a
ModuleHandlerFactory base implementation.BaseThingHandler provides a base implementation for the ThingHandler interface.The
BaseThingHandlerFactory provides a base implementation for the ThingHandlerFactory interface.This is a base class that can be used by TriggerModuleHandler implementations
This class converts binary data to JSON format.
The binary prefixes used to derive units by specific powers of 2.
This exception is used by
BindingConfigReader instances if parsing configurations failsThis interface must be implemented by services, which can parse the generic
binding configuration string used in the
GenericItemProvider.Class that implements a collection for
bits
This class allows the easy construction of a
Bridge instance using the builder pattern.A
BridgeHandler handles the communication between the openHAB framework and
a bridge (a device that acts as a gateway to enable the communication with other devices)
represented by a Bridge instance.The
BridgeType describes a concrete type of a Bridge.Transfer object for broken item channel links.
A wrapper that uninstalls a bundle on close.
The bundle information provided by the openHAB XML files in the
OH-INF directory.Reads all the bundle information provided by XML files in the
OH-INF directory to BundleInfo.Resolve bundle specific information from the framework.
The
BundleVersion wraps a bundle version and provides a method to compare themThe static methods of this class are made available as functions in the scripts.
A representation of the model object 'Button'.
A representation of the model object 'Button Definition'.
An implementation of the model object 'Button Definition'.
A representation of the model object 'Buttongrid'.
An implementation of the model object 'Buttongrid'.
An implementation of the model object 'Button'.
This is an implementation of an
AudioStream with known length and a clone method, which is based on a simple
byte array.This is a simple file based cache implementation.
This item identifies a telephone call by its origin and destination.
A representation of the model object 'Changed Event Trigger'.
An implementation of the model object 'Changed Event Trigger'.
ChannelBuilder is responsible for creating Channels.Builder for a channel definition.
This is a data transfer object that is used to serialize channel definitions.
ChannelDescriptionChangedEvents will be delivered through the openHAB event bus if the
CommandDescription or StateDescription of a channel has changed.This is a data transfer object that is used to serialize channels.
The
ChannelDTOMapper is a utility class to map channels into channel data transfer objects (DTOs).This is a data transfer object that is used to serialize channel group definitions.
The
ChannelGroupType contains a list of ChannelDefinitions and further meta information such as label
and description, which are generally used by user interfaces.A
ChannelGroupType builder.This OSGi service could be used to localize a
ChannelGroupType type using the I18N mechanism of the openHAB
framework.The
ChannelGroupTypeProvider is responsible for providing channel group types.The
ChannelGroupTypeRegistry tracks all ChannelGroupTypes provided by
registered ChannelGroupTypeProviders.The
ChannelGroupTypeUID represents a unique identifier for channel group types.ChannelGroupUID represents a unique identifier for channel groups.The
ChannelHandler defines the interface for converting received ChannelHandlerContent
to States for posting updates to Channels and
Commands to values for sendingThe
ChannelHandlerContent defines the pre-processed responseKind of the channel.
The
ChannelMode enum defines control modes for channelsThe
ChannelTransformation can be used to transform an input value using one or more transformations.ChannelTriggeredEvents can be used to deliver triggers through the openHAB event bus.The
ChannelType describes a concrete type of Channel.Interface for
ChannelTypeBuilder.This is a data transfer object that is used with to serialize channel types.
This OSGi service could be used to localize a
ChannelType using the I18N mechanism of the openHAB
framework.The
ChannelTypeProvider is responsible for providing channel types.The
ChannelTypeUID represents a unique identifier for channel types.ChannelUID represents a unique identifier for channels.The
ChannelValueConverterConfig is a base class for the channel configuration of things
using the ChannelHandlersA representation of the model object 'Chart'.
An implementation of the model object 'Chart'.
Defines the interface for chart providers.
Provides a list of image types
The CIDR (Class-less interdomain routing) notation is an IP address
and additionally ends with a slash followed by the network prefix length number.
This is for an
AudioStream, that can be clonedA representation of the model object 'Color Array'.
An implementation of the model object 'Color Array'.
The
ColorChannelHandler implements ColorItem conversionsA ColorItem can be used for color values, e.g. for LED lights
A representation of the model object 'Colorpicker'.
An implementation of the model object 'Colorpicker'.
A representation of the model object 'Colortemperaturepicker'.
An implementation of the model object 'Colortemperaturepicker'.
The
ColorUtil is responsible for converting different color formats.Color gamut
Class for points in the CIE xy color space
This is a marker interface for all command types.
The
CommandDescription groups state command properties.Used to build instances of
CommandDescription.Implementations provide an item specific, localized
CommandDescription.An implementation of this service provides locale specific
CommandDescriptions for the given item.A representation of the model object 'Command Event Trigger'.
An implementation of the model object 'Command Event Trigger'.
Represents a command option for "write only" command channels.
Contains often used trigger events.
The
CommonWebSocketServlet provides the servlet for WebSocket connections.Provides an exception class for openHAB to be used in case of communication issues with a device
A complex type consists out of a sorted list of primitive constituents.
This class is as
ActionType which logically combines Action instances.This is a data transfer object that is used to serialize the respective class.
This class is as
ConditionType which logically combines Condition modules.This is a data transfer object that is used to serialize the respective class.
This class is as
TriggerType which logically combines Trigger modules.This is a data transfer object that is used to serialize the respective class.
This interface represents automation
Condition modules which are working as a filter for Rule's
executions.A representation of the model object 'Condition'.
This class allows the easy construction of a
Condition instance using the builder pattern.This is a data transfer object that is used to serialize the respective class.
This is a utility class to convert between the respective object and its DTO.
This interface provides common functionality for processing
Condition modules.An implementation of the model object 'Condition'.
This class provides common functionality for creating
Condition instances by supplying their
meta-information.This is a data transfer object that is used to serialize the respective class.
This is a utility class to convert between the respective object and its DTO.
The
ConfigDescription class contains a description for a concrete
configuration of e.g. a Thing, a Bridge or other specific
configurable services.Can be implemented to point one config description URI to another.
The
ConfigDescriptionBuilder class provides a builder for the ConfigDescription class.The
ConfigDescriptionConverter is a concrete implementation of the XStream Converter
interface used to convert config
description information within an XML document into a ConfigDescription object.ConfigDescriptionDTO is a data transfer object for ConfigDescription.ConfigDescriptionDTOMapper maps ConfigDescriptions to the data transfer object
ConfigDescriptionDTO.The
ConfigDescriptionParameter class contains the description of a
concrete configuration parameter.The
ConfigDescriptionParameter.Type defines an enumeration of all supported data types a
configuration parameter can take.The
ConfigDescriptionParameterBuilder class provides a builder for the ConfigDescriptionParameter
class.The
ConfigDescriptionParameterConverter is a concrete implementation
of the XStream Converter interface used to convert config
description parameters information within an XML document into a ConfigDescriptionParameter object.This is a data transfer object that is used to serialize parameter of a configuration description.
The
ConfigDescriptionParameterGroup specifies information about parameter groups.The
ConfigDescriptionParameterGroupBuilder class provides a builder for the
ConfigDescriptionParameterGroup class.The
ConfigDescriptionParameterGroupConverter creates a ConfigDescriptionParameterGroup instance from
an option XML node.This is a data transfer object that is used to serialize options of a
parameter group.
The
ConfigDescriptionProvider can be implemented and registered as an OSGi
service to provide ConfigDescriptions.ConfigDescriptionRegistry provides access to ConfigDescriptions.The
ConfigDescriptionValidator validates a given set of Configuration parameters against a
given ConfigDescription URI.This OSGi service could be used to localize a config description using the I18N mechanism of the openHAB
framework.
The
ConfigOptionProvider can be implemented and registered as an OSGi
service to provide ConfigDescriptions options.Map an OSGi configuration map
Map<String, Object> or type-less value to an individual configuration bean or
typed value.The
ConfigStatusBridgeHandler is an extension of BaseBridgeHandler that implements the
ConfigStatusProvider interface.The
ConfigStatusCallback interface is a callback interface to propagate a new configuration status for an
entity.The
ConfigStatusEventFactory is the event factory implementation to create configuration status events, e.g.The
ConfigStatusInfo contains ConfigStatusMessages to represent the current configuration status of
an entity.Event for configuration status information.
The
ConfigStatusMessage is a domain object for a configuration status message.The builder for a
ConfigStatusMessage object.The
ConfigStatusMessage.Type defines an enumeration of all supported types for a configuration status message.The
ConfigStatusProvider can be implemented and registered as an OSGi service to provide status
information for Configurations of entities.The
ConfigStatusService provides the ConfigStatusInfo for a specific entity.The
ConfigStatusSource represents a source which would like to propagate its new configuration status.The
ConfigStatusThingHandler is an extension of BaseThingHandler that implements the
ConfigStatusProvider interface.ConfigurableService can be used as a marker interface for configurable services.ConfigurableServiceDTO is a data transfer object for configurable services.Provides utility methods for working with
ConfigurableService so the property names can remain hidden.This class is a wrapper for configuration settings of
org.openhab.core.thing.Things.Deserializes a
Configuration object.Provides an exception class for openHAB to be used in case of configuration issues
This class provides utility methods used by
RuleRegistry to resolve and normalize the RuleImpls
configuration values.This class serializes elements of Configuration object into json as configuration object (not as
configuration.properties object).
ConfigurationService manages configurations in the ConfigurationAdmin.The configuration admin service provides us with a map of key->values.
A runtime exception to be thrown if given
Configuration parameters do not match their declaration in the
ConfigDescription.The
ConfigValidationMessage is the result of a specific ConfigDescriptionParameter
validation, e.g. the validation of the required flag or of the min/max attribute.Provides
ConfigDescriptions for configurations which are read from XML files.Provides an exception class for openHAB to be used in case of connection issues with a device
This interface must be implemented by consoles which want to use the
ConsoleInterpreter.Implementing this interface allows a
ConsoleCommandExtension
to provide completions for the user as they write commands.Client which provide a console command have to implement this interface
This class provides generic methods for handling console input (i.e. pure strings).
A ContactItem can be used for sensors that return an "open" or "close" as a state.
ConversionException generic exception for errors which occurs during conversion.The
ConverterAttributeMapValidator class reads any attributes of a node, validates
if they appear or not, and returns the validated key-value pair map.The
ConverterValueMap reads all children elements of a node and provides
them as key-value pair map.CoreItemFactory-Implementation for the core ItemTypesThis class provides static methods mapping methods from package org.openhab.core.util
Marker interface for credentials which can be handled by authentication providers.
Provider of credentials which works in given context and can provide credentials out of it.
This class creates a
TemporalAdjuster that takes a temporal and adjust it to the next
deadline based on a
cron specification.Runnable that can be passed data and can throw a checked exception.
The software utility Cron is a time-based job scheduler in Unix-like computer
operating systems.
A representation of the model object 'Cron Strategy'.
An implementation of the model object 'Cron Strategy'.
The
Currency defines the dimension for currenciesThe
CurrencyProvider can be implemented by services that supply currencies and their exchange ratesThe
CurrencyServiceConfigOptionProvider is an implementation of ConfigOptionProvider for the
available currency providers.The
CurrencyUnit is a UoM compatible unit for currencies.The
CurrencyUnits defines the UoM system for handling currenciesThe
CustomTrustManagerFactory is a TrustManagerFactory that provides a custom TrustManagerRepresents a measure of data amount.
Represents a measure of data or data blocks per unit time passing through a communication link
This interface is a container for group functions that require
DateTimeTypes for its calculations.This calculates the minimum value of all item states of DateType type.
This calculates the maximum value of all item states of DateType type.
A DateTimeItem stores a timestamp including a valid time zone.
A representation of the model object 'Date Time Trigger'.
An implementation of the model object 'Date Time Trigger'.
The decimal type uses a BigDecimal internally and thus can be used for
integers, longs and floating point numbers alike.
A representation of the model object 'Default'.
DefaultAbstractManagedProvider is a specific AbstractManagedProvider implementation, where the stored
element is
the same as the element of the provider.An implementation of the model object 'Default'.
This class defines a provider of all default semantic tags.
This class defines all the default semantic tags.
Implementation providing default system wide channel types
Enumerates all the different modes for generating default translations.
A
Storage that could be disposed.The
DeletableStorageService extends the normal StorageService and provides instances of
DeletableStorages.Define Density type (basic unit is kg/m^3)
This
DeviceCodeResponseDTO is a DTO with fields that encapsulate the data from RFC-8628 device code
responses.Describes dialog configured services and options.
Builder for
DialogContext
Allows to describe a dialog context without requiring the involved services to be loadedDescribes dialog desired services and options.
The
DimmerChannelHandler implements DimmerItem conversionsA DimmerItem can be used as a switch (ON/OFF), but it also accepts percent values
to reflect the dimmed state.
This is a data transfer object that is used to serialize the information about binding discovery.
The
DiscoveryListener interface for receiving discovery events.The
DiscoveryResult is a container for one result of a discovery process.The
DiscoveryResultBuilder helps creating a DiscoveryResult through the builder pattern.This is a data transfer object that is used to serialize discovery results.
The
DiscoveryResultDTOMapper is a utility class to map discovery results into discovery result transfer
objects.The
DiscoveryResultFlag class specifies a list of flags
which a DiscoveryResult object can take.The
DiscoveryService is a service interface which each binding can
implement to provide an auto discovery process for one or more Thing s.The
DiscoveryServiceRegistry is a service interface which provides
the following features.For resource needing a callback when they are not needed anymore.
Interface of a provider that can provide Xbase-relevant object structures for
a purely string based script.
Utilities for mapping/transforming DTOs.
Static utility methods that are helpful when dealing with
Duration.Implementations may provide
Channel specific CommandDescriptions.The
DynamicStateDescriptionProvider is responsible for providing StateDescription for a
Channel dynamically in the runtime.Conductivity of an electrolyte solution is a measure of its ability to conduct electricity.
Define emission intensity type (basic unit is g/kWh)
See Wikipedia
Class representing pooling related configuration of a single endpoint
This class implements equals hashcode constract, and thus is suitable for use as keys in HashMaps, for example.
The
EnergyPrice defines the dimension for pricesThis is a data transfer object that is used to serialize channels with dynamic data like linked items.
The
EnrichedConfigDescriptionDTOMapper is a utility class to map ConfigDescriptions to config
descriptions data transform objects ConfigDescriptionDTO containing
EnrichedConfigDescriptionParameterDTO.This is an enriched data transfer object that is used to serialize config descriptions parameters with a list of
default values if a configuration description defines
multiple="true".This is an enriched data transfer object that is used to serialize group items.
This is an enriched data transfer object that is used to serialize items channel links with dynamic data like the
editable flag.
The
EnrichedItemChannelLinkDTOMapper is a utility class to map item channel links into enriched item channel
link data transform objects (DTOs).This is an enriched data transfer object that is used to serialize items with dynamic data like the state, the state
description and the link.
The
EnrichedItemDTOMapper is a utility class to map items into enriched item data transform objects (DTOs).This is a data transfer object that is used to serialize things with dynamic data like the status.
The
EnrichedThingDTOMapper is a utility class to map things into enriched thing data transfer objects
(DTOs).The static methods of this class are made available as functions in the scripts.
This service provides functionality around days of the year and is the central
service to be used directly by others.
A representation of the model object 'Equals Filter'.
An implementation of the model object 'Equals Filter'.
This is the super interface for all types that represent an Equipment.
Event objects are delivered by the EventPublisher through the openHAB event bus.Describes event options and gives information how to interpret it.
The
EventDTO is used for serialization and deserialization of eventsA representation of the model object 'Event Emitted Trigger'.
An implementation of the model object 'Event Emitted Trigger'.
An
EventFactory is responsible for creating Event instances of specific event types.An
EventFilter can be provided by an EventSubscriber in order
to receive specific Events by an EventPublisher if the filter applies.Describes one possible value an event might have.
The
EventProcessingException is thrown when processing of incoming events failsThe
EventPublisher posts Events through the openHAB event bus in an asynchronous way.The
EventSubscriber defines the callback interface for receiving events from
the openHAB event bus.A representation of the model object 'Event Trigger'.
An implementation of the model object 'Event Trigger'.
These are the event types that can occur as model repository changes
Due to the duality of some types (which can be states and commands at the
same time), we need to be able to differentiate what the meaning of a
message on the bus is - does "item ON" mean that its state has changed to
ON or that it should turn itself ON?
The
EventWebSocket is the WebSocket implementation that extends the event busThe
EventWebSocketAdapter allows subscription to oh events over WebSocketThis class provides static methods that can be used in automation rules for
executing commands on command line.
Some common methods to execute commands on command line.
An
ExecutionEvent is only used to notify rules when a script or the REST API trigger the run.This is a simple expiring and reloading cache implementation.
Complementary class to
ExpiringCache, implementing an asynchronous variant
of an expiring cache.This is a simple expiring and reloading multiple key-value-pair cache implementation.
Base class for all expressions.
Expression that successfully parses, if a given expression occurs or repeats with a specified cardinality.
Expression that successfully parses, if a thing identifier token is found.
Expression that decorates the resulting (proxied) AST node of a given expression by a name, value and tag.
Expression that successfully parses, if a given string constant is found.
Expression that successfully parses, if a sequence of given expressions is matching.
Provides an extensible composite TrustManager
The trust manager can be extended with implementations of the following interfaces:
-
TlsTrustManagerProvider
- TlsCertificateProviderThe dashboard tile for external services.
This is an AudioStream from an audio file
The
FileTransformationProvider implements a TransformationProvider for
supporting transformations stored in configuration filesA representation of the model object 'Filter'.
The
FilterCriteria specifies a filter for dynamic selection list
providers of a ConfigDescriptionParameter.This class is used to define a filter for queries to a
PersistenceService.Enumeration with all possible compare options
Enumeration with all ordering options
This is a data transfer object that is used to serialize filter criteria of a
parameter.
A representation of the model object 'Filter Details'.
An implementation of the model object 'Filter Details'.
An implementation of the model object 'Filter'.
The builder to create a
Firmware.This is a data transfer object that is used to serialize firmware information.
The
FirmwareEventFactory is registered as an OSGi service and is responsible to create firmware events.The
FirmwareProvider is registered as an OSGi service and is responsible for providing firmwares.The
FirmwareRegistry is registered as an OSGi service and is responsible for tracking all
FirmwareProviders.A function for defining specific installation restrictions for a given
Firmware.This is a data transfer object that is used to serialize firmware status information.
The
FirmwareUpdateBackgroundTransferHandler is an extension of the FirmwareUpdateHandler and is to be
used if the firmware of the thing must be transferred to the actual device in the background.The
FirmwareUpdateHandler can be implemented and registered as an OSGi service in order to update the
firmware for the physical device of a Thing.The
FirmwareUpdateProgressInfo represents the progress indicator for a firmware update.The
FirmwareUpdateProgressInfoEvent is sent if there is a new progress step for a firmware update.The
FirmwareUpdateResult enumeration defines the possible results for a firmware update.The
FirmwareUpdateResultInfo contains information about the result of a firmware update.The
FirmwareUpdateResultInfoEvent is sent if the firmware update has been finished.The firmware update service is registered as an OSGi service and is responsible for tracking all available
FirmwareUpdateHandlers.Deprecated.
You should consider using
ClonableAudioStream and/or SizeableAudioStream to detect audio
stream capabilitiesThe
FixedValueMappingChannelHandler implements mapping conversions for different item-typesA representation of the model object 'Frame'.
An implementation of the model object 'Frame'.
Generates the default translations properties file for a bundle based on the XML files in the
OH-INF
directory.The
GenericChannelHandler implements simple conversions for different item typesThe abstract base class for all items.
The
GenericUnmarshaller is an abstract implementation of the XStream Converter interface used
to convert XML tags within an XML document into its
according objects.Represents a generic
User with a set of rolesThis class defines a few persistence strategies that are globally available to
all persistence models.
A representation of the model object 'Group'.
A representation of the model object 'Group Config'.
An implementation of the model object 'Group Config'.
A representation of the model object 'Group Exclude Config'.
An implementation of the model object 'Group Exclude Config'.
Group functions are used by active group items to calculate a state for the group
out of the states of all its member items.
This is the default group function that does nothing else than to check if all member items
have the same state.
This is a data transfer object that is used to serialize group functions.
An implementation of the model object 'Group'.
This is a data transfer object that is used to serialize group items.
GroupItemStateChangedEvents can be used to deliver group item state changes through the openHAB event bus.A representation of the model object 'Group Member Changed Event Trigger'.
An implementation of the model object 'Group Member Changed Event Trigger'.
A representation of the model object 'Group Member Command Event Trigger'.
An implementation of the model object 'Group Member Command Event Trigger'.
A representation of the model object 'Group Member Update Event Trigger'.
An implementation of the model object 'Group Member Update Event Trigger'.
GroupStateUpdatedEvents can be used to deliver group item state updates through the openHAB event bus.Handler which is responsible for processing request and response.
Handler context represents a present state of all handlers placed in execution chain.
Constants for making handlers in proper order.
Static utility methods that are helpful when dealing with hex data and byte arrays.
This interface is used by persistence services to represent an item
with a certain state at a given point in time.
The HSBType is a complex type with constituents for hue, saturation and
brightness and can be used for color items.
This class provides static methods that can be used in automation rules
for sending HTTP requests
Factory class to create Jetty http clients
This exception is thrown, if an unexpected error occurs during initialization of the Jetty client
Create
HttpContext instances when registering servlets, resources or filters using the
HttpService.registerServlet(java.lang.String, javax.servlet.Servlet, java.util.Dictionary<?, ?>, org.osgi.service.http.HttpContext) and corresponding methods.Builder class to construct http requests
Some utility functions related to the http service
Some common methods to be used in HTTP-In-Binding, HTTP-Out-Binding and other bindings
For advanced usage direct use of the Jetty client is preferred
This is the interface that a human language text interpreter has to implement.
An icon provider can provide
InputStreams for icons.A representation of the model object 'Icon Rule'.
An implementation of the model object 'Icon Rule'.
This is a bean that provides some meta-information about available icon sets.
Data format of icons
Interface for classes that instances provide an identifier.
A representation of the model object 'ID Unit'.
An implementation of the model object 'ID Unit'.
A representation of the model object 'Image'.
The
ImageChannelHandler implements ImageItem conversionsAn implementation of the model object 'Image'.
An ImageItem holds the binary image data as its status.
Imperial units used for the United States and Liberia.
The
Inbox is a service interface providing a container for discovered Things
(e.g. found by a DiscoveryService) as DiscoveryResults.An
InboxAddedEvent notifies subscribers that a discovery result has been added to the inbox.Components implementing this interface participate in the
AutomaticInboxProcessor's
decision whether to automatically approve an inbox result or not.An
InboxEventFactory is responsible for creating inbox event instances.The
InboxListener interface for receiving Inbox events.Implements static factory methods for
Predicates to filter in streams of DiscoveryResults.An
InboxRemovedEvent notifies subscribers that a discovery result has been removed from the inbox.An
InboxUpdatedEvent notifies subscribers that a discovery result has been updated in the inbox.A representation of the model object 'Include Filter'.
An implementation of the model object 'Include Filter'.
This class defines meta-information properties, used by the Rule Engine when creating connections between
modules.
A representation of the model object 'Input'.
An implementation of the model object 'Input'.
Each cache result instance can handle several
InputStreams.This class provides a unique ID for the instance that can be used for identification, e.g. when
integrating with external systems.
This interface represents the intensity dimension.
An exception used by
HumanLanguageInterpreters, if an error occurs.Bundles results of an interpretation.
This is a
IpAddonFinder for finding suggested add-ons by sending IP packets to the
network and collecting responses.
This interface defines the core features of an openHAB item.
An
ItemAddedEvent notifies subscribers that an item has been added.This class allows the easy construction of an
Item using the builder pattern.Creates a new
ItemBuilder which is based on all available ItemFactorys.An
ItemChannelLinkAddedEvent notifies subscribers that an item channel link has been added.This is a data transfer object that is used to serialize links.
The
ItemChannelLinkProvider is responsible for providing item channel
links.An
ItemChannelLinkRemovedEvent notifies subscribers that an item channel link has been removed.ItemCommandEvents can be used to deliver commands through the openHAB event bus.A representation of the model object 'Item Config'.
An implementation of the model object 'Item Config'.
This is a data transfer object that is used to serialize items.
The
ItemDTOMapper is a utility class to map items into item data transfer objects (DTOs).ItemEvent is an abstract super class for all command and state item events.An
ItemEventFactory is responsible for creating item event instances, e.g.The
EventDTO is used for serialization and deserialization of eventsA representation of the model object 'Item Exclude Config'.
An implementation of the model object 'Item Exclude Config'.
This Factory creates concrete instances of the known ItemTypes.
ItemFileGenerator is the interface to implement by any file generator for Item object.This is a java bean that is used to serialize items to JSON.
This is a java bean that is used to serialize item lists.
This is an abstract parent exception to be extended by any exceptions
related to item lookups in the item registry.
A representation of the model object 'Item Model'.
An implementation of the model object 'Item Model'.
This exception is thrown by the
ItemRegistry if an item could
not be found.This exception can be thrown whenever a search pattern does not uniquely identify
an item.
Provides some default predicates that are helpful when working with items.
An item provider provides instances of
GenericItem.The ItemRegistry is the central place, where items are kept in memory and their state
is permanently tracked.
This is a listener interface which should be implemented where ever the item registry is
used in order to be notified of any dynamic changes in the provided items.
An
ItemRemovedEvent notifies subscribers that an item has been removed.The Adapter Factory for the model.
This is a representation of an item semantics configuration problem.
The Factory for the model.
An implementation of the model Factory.
This class contains custom formatting description.
Generates code from your model files on save.
Use this class to register ide components.
Initialization support for running Xtext languages as language servers.
The Package for the model.
Defines literals for the meta objects that represent
each class,
each feature of each class,
each enum,
and each data type
An implementation of the model Package.
Use this class to register components to be used at runtime / without the Equinox extension registry.
This class contains custom scoping description.
Initialization support for running Xtext languages
without equinox extension registry
The Switch for the model's inheritance hierarchy.
ItemStateChangedEvents can be used to deliver item state changes through the openHAB event bus.ItemStateEvents can be used to deliver item status updates through the openHAB event bus.This event announces potential item state outcomes when a command was received.
ItemStateUpdatedEvents can be used to report item status updates through the openHAB event bus.Custom validation rules.
The
ItemTimeSeriesEvent can be used to report item time series updates through the openHAB event bus.The
ItemTimeSeriesUpdatedEvent can be used to report item time series updates through the openHAB event bus.This interface describes the methods that need to be implemented by a provider that
wants to define the appearance of an item in the UI.
This interface is used by a service which combines the core item registry
with an aggregation of item ui providers; it can be therefore widely used for
all UI related information requests regarding items.
An
ItemUpdatedEvent notifies subscribers that an item has been updated.JavaOSGiTest is an abstract base class for OSGi based tests.JavaTest is an abstract base class for tests which are not necessarily based on OSGi.Marker interface for an input stream that provides a JSON string.
Static helper methods to build up JSON-like Response objects and error handling.
trap exceptions
Converts JSON based
BundleInfo to Translations.This is the interface that an edge keyword spotting service has to implement.
A tagging interface for keyword spotting events.
General purpose keyword spotting exception
The listener interface for receiving
KSEvent events.This is the interface that a keyword spotting service has to implement.
A handle to a
KSServiceScriptExtensionProvider which providers a 'lifecycleTracker' object allowing scripts to register for disposal events.
A representation of the model object 'Linkable Widget'.
An implementation of the model object 'Linkable Widget'.
This is an
EventFactory for creating link events.The interface describe a provider for a locale.
Provides helper method for working with locales.
LocaleServiceImpl provides helper method for working with locales in REST
resources.Common class (used as key) for i18n to store a localized object in a cache.
This is the super interface for all types that represent a Location.
A LocationItem can be used to store GPS related informations, addresses...
This interface describes a provider for a location.
The static methods of this class are made available as functions in the scripts.
The
LogDTO is used for serialization and deserialization of log messagesThe
LogFilterDTO is used for serialization and deserialization of log filtersThe
LogWebSocket is the WebSocket implementation for logs.The
LogWebSocketAdapter allows subscription to log events over WebSocketCache system for media files, and their metadata
This is a LRU cache (least recently used entry is evicted if the size
is exceeded).
A cached media entry resulting from a call to a supplier or a load from disk
This class also adds the capability to serve multiple InputStream concurrently
without asking already retrieved data to the wrapped stream.
ThingHandler which provides annotated actions that will become Action modules for the automation engine
The
MagicBindingConstants class defines common constants, which are
used across the whole binding.The
MagicBridgedThingHandler is responsible for handling commands, which are
sent to one of the channels.The
MagicBridgeHandler serves as a handler for magic bridges.The
MagicButtonHandler is capable of triggering different events.ThingHandler that randomly sends numbers and strings to channels based on a configured interval
The
MagicColorLightHandler is responsible for handling commands, which are
sent to one of the channels.Handler for thing with a configuration parameter
The
MagicContactHandler is responsible for handling commands, which are
sent to one of the channels.ThingHandler for a thing that goes online after 15 seconds
The
MagicDimmableLightHandler is responsible for handling commands, which are
sent to one of the channels.ThingHandler which provides channels with dynamic state descriptions.
A handler for an extensible thing.
Handler for firmware updatable magic things.
The
MagicImageHandler is responsible for handling commands, which are
sent to one of the channels.The
MagicLocationThingHandler is responsible for handling commands, which are
sent to one of the channels.Testing service for multi-context configurations.
The
MagicOnlineOfflineHandler is responsible for handling commands, which are
sent to one of the channels.The
MagicOnOffLightHandler is responsible for handling commands, which are
sent to one of the channels.The
MagicPlayerHandler is responsible for handling commands, which are
sent to one of the channels.The
MagicRollershutterHandler is responsible for handling commands, which are
sent to one of the channels.A public interface for a service from this virtual bundle which is also a
ConfigOptionProvider.A handler for a thermostat thing.
The
MagicTimeSeriesHandler is capable of providing a series of different forecastsManagedItemChannelLinkProvider is responsible for managed ItemChannelLinks at runtime.ManagedItemProvider is an OSGi service, that allows to add or remove
items at runtime by calling ManagedItemProvider.add(org.openhab.core.items.Item) or ManagedItemProvider.remove(java.lang.String).ManagedMetadataProvider is an OSGi service interface that allows to add or remove
metadata for items at runtime.The
ManagedPersistenceServiceConfigurationProvider implements a
PersistenceServiceConfigurationProvider for managed configurations which are stored in a JSON databaseThe
ManagedProvider is a specific Provider that enables to
add, remove and update elements at runtime.Implementation of a rule provider that uses the storage service for persistence
ManagedSemanticTagProvider is an OSGi service, that allows to add or remove
semantic tags at runtime by calling AbstractManagedProvider.add(E)
or AbstractManagedProvider.remove(K).ManagedThingProvider is an OSGi service, that allows to add or remove
things at runtime by calling AbstractManagedProvider.add(E) or
AbstractManagedProvider.remove(K).The
ManagedTransformationProvider implements a TransformationProvider for
managed transformations stored in a JSON databaseA
User sourced from a managed UserProvider.A representation of the model object 'Mapping'.
An implementation of the model object 'Mapping'.
A representation of the model object 'Mapview'.
An implementation of the model object 'Mapview'.
This interface can be implemented by services that want to register as handlers for specific marketplace add-on
content types and content types.
Handle the management of bundles related to marketplace add-ons that resists OSGi cache cleanups.
This class contains constants used in marketplace add-on services
This is an exception that can be thrown by
MarketplaceAddonHandlers if some operation fails.This is a
MDNSAddonFinder for finding suggested add-ons via mDNS.This interface defines how to get an JmDNS instance
to access Bonjour/MDNS
A
MDNSDiscoveryParticipant that is registered as a service is picked up by the MDNSDiscoveryService
and can thus contribute DiscoveryResults from
mDNS scans.This interface defines how to use JmDNS based service discovery
to register and unregister services on Bonjour/MDNS
This is a data class for storing meta-data for a given item and namespace.
The
MetadataAwareItem is an interface that can be implemented by Items that need to be notified of
metadata changes.A
MetadataConfigDescriptionProvider implementation can be registered as an OSGi service in order to give
guidance to UIs what metadata namespaces should be available and what metadata properties are expected.This is a data transfer object that is used to serialize metadata for a certain namespace and item.
This class represents the key of a
Metadata entity.Provides some default predicates that are helpful when working with metadata.
This is a marker interface for metadata provider implementations that should be used to register those as an OSGi
service.
The MetadataRegistry is the central place, where additional information about items is kept.
The
MeterRegistryProvider interface provides a means to retrieve the default OH meter registry instanceThe metric prefixes used to derive units by specific powers of 10.
Utilities for working with binary data.
Interface for interacting with a particular modbus slave.
Exception for connection issues
Constants for Modbus transport
== Regarding maximum read and write limits ==
Maximum number of registers that are allowed to be read.
Value types for different number types.
Callback used to report failure in Modbus
Common base class for ip based endpoints.
ModbusManager is the main interface for interacting with Modbus slaves
Interface for read callbacks
Modbus read function codes supported by this transport
Implementation of immutable representation of modbus read request
Equals and hashCode implemented keeping
PollTask in mind: two instances of this class are considered the same
if they have
the equal parameters (same slave id, start, length, function code and maxTries).Immutable
ModbusRegisterArray implementationMinimal representation of a modbus response.
Base interface for callbacks used in Modbus
Serial endpoint.
ModbusSlaveEndpoint contains minimal connection information to establish connection to the slave.
Visitor for ModbusSlaveEndpoint
Exception for explicit exception responses from Modbus slave
Enum for known exception codes that modbus slaves (servers) can used to indicate exceptions
Exception for all IO errors
Endpoint for TCP slaves
Base exception for all exceptions in Modbus transport bundle
Endpoint for UDP slaves
Exception representing situation where function code of the response does not match request
Exception representing situation where data length of the response does not match request
Exception representing situation where transaction id of the response does not match request
Interface for write callbacks
Implementation for writing coils
Modbus write function codes supported by this transport
Implementation for writing registers
Base interface for Modbus write requests
ModbusWriteRequestBlueprintVisitor interface.
A representation of the model object 'Model Binding'.
An implementation of the model object 'Model Binding'.
A representation of the model object 'Model Bridge'.
An implementation of the model object 'Model Bridge'.
A representation of the model object 'Model Channel'.
An implementation of the model object 'Model Channel'.
This class holds all important constants relevant for this bundle.
A representation of the literals of the enumeration 'Model Group Function',
and utility methods for working with them.
A representation of the model object 'Model Group Item'.
An implementation of the model object 'Model Group Item'.
A representation of the model object 'Model Item'.
An implementation of the model object 'Model Item'.
A representation of the model object 'Model Normal Item'.
An implementation of the model object 'Model Normal Item'.
This interface has to be implemented by services that register an EMF model parser
A representation of the model object 'Model Property'.
A representation of the model object 'Model Property'.
A representation of the model object 'Model Property Container'.
An implementation of the model object 'Model Property Container'.
An implementation of the model object 'Model Property'.
An implementation of the model object 'Model Property'.
The model repository stores the configuration files (EMF models).
A representation of the model object 'Model Thing'.
An implementation of the model object 'Model Thing'.
This class provides an interface to the a
PersistenceService to allow data to be stored
at a specific time.This interface represents automation
Modules which are building components of the Rules.This class allows the easy construction of a
Module instance using the builder pattern.This is a data transfer object that is used to serialize the respective class.
This is a utility class to convert between the respective object and its DTO.
A common interface for all module Handler interfaces.
This class is responsible to provide a
RegistryChangeListener logic.This interface represents a factory for
ModuleHandler instances.Wrapper class to collect information about actions modules to be created
This class provides common functionality for creating
ModuleType instances.This is a data transfer object that is used to serialize the respective class.
This is a utility class to convert between the respective object and its DTO.
Interface for a service that offer i18n functionality
This interface has to be implemented by all providers of
ModuleTypes.This interface provides functionality to get available
ModuleTypes.Implement this to be notified of the success or error of any method in
MqttBrokerConnection that takes a
callback.An MQTTBrokerConnection represents a single client connection to a MQTT broker.
Create a listener object for being used as a callback for a connection attempt.
MQTT version (currently v3 and v5)
MQTT transport protocols
Contains configuration for a MqttBrokerConnection.
Implement this interface to get notified of connection state changes.
The connection state of a
MqttBrokerConnection.Thrown if an error occurs communicating with the server.
Implement this interface and register on the to get notified
of incoming Mqtt messages on the given topic.
Class encapsulating the last will and testament that is published after the client has gone offline.
Thread factory that applies a thread name constructed by a supplied identifier.
Some utility functions related to network interfaces etc.
This is an interface for listeners who wants to be notified for the change of network address.
Interface that provides access to configured network addresses
This type is used by the
PlayerItem.The
NodeAttributes class contains all attributes for an XML tag.The
NodeAttributesConverter is a concrete implementation of the XStream Converter interface
used to convert the attributes of an XML tag within an XML
document into a NodeAttributes object.The
NodeIterator is an Iterator for nodes of an XML document.The
NodeList class contains the node name and its according list of values for an XML tag.The
NodeListConverter is a concrete implementation of the XStream Converter interface used to
convert a list of XML tags within an XML document
into a NodeList object.The
NodeName interface defines common features for all Node* classes.The
NodeValue class contains the node name and its according value for an XML tag.The
NodeValueConverter is a concrete implementation of the XStream Converter interface used
to convert the value of an XML tag within an XML
document into a NodeValue object.A representation of the model object 'Non Linkable Widget'.
An implementation of the model object 'Non Linkable Widget'.
A representation of the model object 'Not Equals Filter'.
An implementation of the model object 'Not Equals Filter'.
A representation of the model object 'Not Include Filter'.
An implementation of the model object 'Not Include Filter'.
The
NumberChannelHandler implements NumberItem conversionsThis class contains all kinds of extensions to be used by scripts and not
provided by Xbase.
A NumberItem has a decimal value and is usually used for all kinds
of sensors, like temperature, brightness, wind, etc.
This is the service factory to produce an OAuth2 service client that authenticates using OAUTH2.
For all exceptions arising during oauth.
The OAuth Factory interface
This is an exception class for OAUTH specific errors. i.e.
This object contains factory methods for each
Java content interface and Java element interface
generated in the https.openhab_org.schemas.addon_info_list.v1_0 package.
This object contains factory methods for each
Java content interface and Java element interface
generated in the org.openhab.core.config.core.dto package.
An endpoint to generate and provide an OpenAPI description.
Some core static methods that provide information about the running openHAB instance.
OptimizingFeatureScopeTrackerProvider implementation
...with a workaround for https://github.com/eclipse/xtext-extras/issues/144Serializes map data by ordering the keys
Serializes set by ordering the elements
This class defines meta-information properties, used by the Rule Engine when creating connections between
modules.
The
ParameterOption specifies one option of a static selection list.This is a data transfer object that is used to serialize options of a
parameter.
This interface provides opportunity to plug different parsers, for example JSON, GSON or other.
This class extends the
Exception class functionality with functionality serving to accumulate the all
exceptions during the parsing process.This class extends the
Exception class functionality with keeping additional information about reasons for
exception during the parsing process.The
PEMTrustManager is a X509ExtendedTrustManager implementation which loads a certificate in
PEM format and validates it against the servers certificate.The pending information used in an OAuth2 authorization flow, set after the user has authorized the client to access
resources, and has been redirected to the callback URI with an authorization code.
The PercentType extends the
DecimalType by putting constraints for its value on top (0-100).This is an implementation of the
AbstractReconnectStrategy.Scheduler that runs the same job at the given periods.
This interface is used by persistence services to represent the full persisted state of an item, including the
previous state, and last update and change timestamps.
The Adapter Factory for the model.
This class represents the configuration that stand for "using all items".
This class is a base class that needs to be used by every item configuration.
A representation of the model object 'Configuration'.
An implementation of the model object 'Configuration'.
This class holds a cron expression based strategy to persist items.
The
PersistenceCronStrategyDTO is used for transferring persistence cron
strategiesThe
PersistenceEqualsFilter is a filter that allows only specific values to passThis class provides static methods that can be used in automation rules
for using persistence services
The Factory for the model.
An implementation of the model Factory.
The
PersistenceFilter is the base class for implementing persistence filters.The
PersistenceFilterDTO is used for transferring persistence filter
configurationsThis class contains custom formatting description.
Generates code from your model files on save.
This class represents the configuration that is used for group items.
This class represents the configuration that is used for excluding group items.
Use this class to register ide components.
Initialization support for running Xtext languages as language servers.
The
PersistenceIncludeFilter is a filter that allows only specific values to passThis class represents the configuration that identify item(s) by name.
This class holds the configuration of a persistence strategy for specific items.
The
PersistenceItemConfigurationDTO is used for transferring persistence
item configurationsThis class represents the configuration that identify item(s) by name for exclusion.
This class provides information about an item that is stored in a persistence service.
The
PersistenceManager interface is used to communicate between external components (e.g.A representation of the model object 'Model'.
An implementation of the model object 'Model'.
The Package for the model.
Defines literals for the meta objects that represent
each class,
each feature of each class,
each enum,
and each data type
An implementation of the model Package.
Use this class to register components to be used at runtime / without the Equinox extension registry.
This class contains custom scoping description.
A persistence service which can be used to store data from openHAB.
The
PersistenceServiceConfiguration represents the configuration for a persistence service.The
PersistenceServiceConfigurationDTO is used for transferring persistence service configurationsThe
PersistenceServiceConfigurationDTOMapper is a utility class to map persistence configurations for storageThe
PersistenceServiceConfigurationProvider is an interface for persistence service configuration providersThe
PersistenceServiceConfigurationRegistry is the central place to store persistence service configurations.The
PersistenceServiceConfigurationRegistryChangeListener is an interface that can be implemented by services
that need to listen to the PersistenceServiceConfigurationRegistry when more than one registry with different
types is used.This is a java bean that is used to serialize services to JSON.
This is the interface for a central service that provides access to
PersistenceServices.Initialization support for running Xtext languages
without equinox extension registry
This class holds a strategy to persist items.
The
PersistenceStrategyDTO is used for transferring persistence strategies.The Switch for the model's inheritance hierarchy.
The
PersistenceThresholdFilter is a filter to prevent persistence based on a threshold.The
PersistenceTimeFilter is a filter to prevent persistence base on intervals.Custom validation rules.
This Action checks the vitality of the given host.
This is an implementation of an
AudioStream used to transmit raw audio data to a sink.The
PipedAudioStream.Group is an OutputStream implementation that can be use to
create one or more PipedAudioStream instances and write to them at once.The
PlayerChannelHandler implements RollershutterItem
conversionsAn
PlayerItem allows to control a player, e.g. an audio player.This type is used by the
PlayerItem.This is the super interface for all types that represent a Point.
This type can be used for items that are dealing with GPS or
location awareness functionality.
Poll task represents Modbus read request
Must be hashable.
Exception that marks that a port is currently already in use.
A primitive type consists of a single value like a string, a number, etc.
This is a
ProcessAddonFinder for finding suggested add-ons by checking processes running
on the openHAB server.Private record to extract match property parameters from a
ProcessHandle.Info object.Common ancestor of all profile types.
Implementors can give advice which
Profiles can/should be used for a given link.Gives access to the framework features for continuing the communication flow.
The profile's context
It gives access to related information like the profile's configuration or a scheduler.
Implementors are capable of creating
Profile instances.Describes a profile type.
Builder for
ProfileType instances.DTO for profile types
The
ProfileTypeDTOMapper is a utility class to map profile-types into profile-type data transfer
objects (DTOs).This OSGi service could be used to localize a
ProfileType using the i18n mechanism of the openHAB framework.A
ProfileTypeProvider is responsible for providing ProfileTypes.Identifier of a profile type.
The
ProgressCallback is injected into the
FirmwareUpdateHandler.updateFirmware(Firmware, ProgressCallback) operation in order to post progress
information about the firmware update process.The
ProgressStep enumeration defines the possible progress steps for a firmware update.Converts the translation key/value pairs of properties files to
Translations.This is the super interface for all property tags.
Holds the
ProtocolType.PathType, which specifies whether its a local or remote path and the scheme.Remote (NET) or Local path.
A
Provider provides elements of a determined type and the subinterfaces
are registered as OSGi services.ProviderChangeListener can be added to Provider services, to
listen for changes.The
ProviderItemChannelLinkRegistry is implementing a Registry to provide a comfortable way to
provide ItemChannelLinks from scripts without worrying about the need to remove them again when the script is
unloaded.The
ProviderItemRegistryDelegate is wrapping a ItemRegistry to provide a comfortable way to provide
items from scripts without worrying about the need to remove items again when the script is unloaded.The
ProviderMetadataRegistryDelegate is wrapping a MetadataRegistry to provide a comfortable way to
provide items from scripts without worrying about the need to remove metadata again when the script is unloaded.The
ProviderThingRegistryDelegate is wrapping a ThingRegistry to provide a comfortable way to provide
Things from scripts without worrying about the need to remove Things again when the script is unloaded.A representation of the model object 'Quantity Literal'.
An implementation of the model object 'Quantity Literal'.
The measure type extends DecimalType to handle physical unit measurement
This interface is a container for dimension based functions that require
QuantityTypes for its calculations.Calculates the average of a set of item states whose value could be converted to the 'referenceUnit'.
Calculates the maximum of a set of item states whose value could be converted to the 'referenceUnit'.
Calculates the median of a set of item states whose value could be converted to the 'referenceUnit'.
Calculates the minimum of a set of item states whose value could be converted to the 'referenceUnit'.
Calculates the sum of a set of item states whose value could be converted to the 'referenceUnit'.
A queryable persistence service which can be used to store and retrieve
data from openHAB.
This is a thread pool executor service, which works as a developer would expect it to work.
The
RadiantExposure defines the dimension for Radiant Exposure
https://en.wikipedia.org/wiki/Radiant_exposureDefine Specific activity type (basic unit is Bq/m^3)
This type can be used for all binary data such as images, documents, sounds etc.
This is a token, identifying something to be completed.
Filter for
ReadyMarkers which a ReadyTracker is interested in.Utilities for the ready maker usage.
Registry for
ReadyMarkers.Tracker for changes related to
ReadyMarker registrations.A
STTEvent fired when the STTService starts recognition.A
STTEvent fired when the STTService stops recognition.Resolves Module references.
The
Registry interface represents a registry for elements of the type
E.RegistryChangedRunnableListener can be added to Registry services, to execute a given
Runnable on all types of changes.RegistryChangeListener can be added to Registry services, to
listen for changes.The
ResourceBundleClassLoader is a user defined classloader which is
responsible to map files within an OSGi bundle to URLs.Public constants for the REST API
This is a marker interface for REST resource implementations
This type is used by the
PlayerItem.Interface defining constants for roles within the framework.
The
RollershutterChannelHandler implements RollershutterItem
conversionsA RollershutterItem allows the control of roller shutters, i.e.
A root component is a special type of
UIComponent at the root of the hierarchy.A representation of the model object 'Rule'.
Represents an expression plus action code that will be executed after successful parsing.
Context for rule execution.
This enum represent the different states a rule can have in respect to rule templates.
Marker annotation for an action module
An
RuleAddedEvent notifies subscribers that a rule has been added.This class allows the easy construction of a
Rule instance using the builder pattern.This is a data transfer object that is used to serialize rules.
This is a utility class to convert between the respective object and its DTO.
Expected execution of a
Rule.An implementation of the model object 'Rule'.
This class is responsible to provide a
RegistryChangeListener logic.A representation of the model object 'Rule Model'.
An implementation of the model object 'Rule Model'.
This class add support for prefixes for
Rule UIDs and provide default predicates for prefixes and tags.This class is responsible for providing
Rules.The
RuleRegistry provides basic functionality for managing Rules.An
RuleRemovedEvent notifies subscribers that a rule has been removed.The Adapter Factory for the model.
The class cache used by the
RulesClassFinder for resolving classes in DSL rules.This is a customized version of the
ClassFinder.The Factory for the model.
An implementation of the model Factory.
This class contains custom formatting description.
Use this class to register ide components.
Initialization support for running Xtext languages as language servers.
This class registers all statically available functions as well as the
extensions for specific jvm types, which should only be available in rules,
but not in scripts
This is a customized version of
JavaReflectAccess.Infers a JVM model from the source model.
The Package for the model.
Defines literals for the meta objects that represent
each class,
each feature of each class,
each enum,
and each data type
An implementation of the model Package.
The
RulesRefresher is responsible for reloading rules resources every time.Use this class to register components to be used at runtime / without the Equinox extension registry.
This class contains custom scoping description.
Initialization support for running Xtext languages
without equinox extension registry
The Switch for the model's inheritance hierarchy.
This enumeration is used to present the main status of a
Rule.This enumeration is used to represent a detail of a
RuleStatus.This class is used to present status of a rule.
An
RuleStatusInfoEvent notifies subscribers that a rule status has been updated.The
RuleSupportRuleRegistryDelegate is wrapping a RuleRegistry to provide a comfortable way to add
rules to the RuleManager without worrying about the need to remove rules again.Custom validation rules.
This class is used to define
Rule Templates which are shared combination of ready to use modules, which can
be configured to produce Rule instances.This is a data transfer object that is used to serialize the rule templates.
This is a utility class to convert between the Rule Templates and RuleTemplateDTO objects.
This interface provides basic functionality for managing
RuleTemplates.An
RuleUpdatedEvent notifies subscribers that a rule has been updated.Specific serial port implementation.
OSGi service to obtain a
SafeCallerBuilder.Builder to create a safe-call wrapper for another object.
Service interface to execute EMF methods in a single based thread.
The
ScanListener interface for receiving scan operation events.Interface returned by all scheduled jobs.
A Scheduler service provides timed semantics to CompletableFutures.
Runnable that can throw checked exceptions.
Interface that extends
TemporalAdjuster and adds more functionality.This interface is implemented by openHAB scripts.
A representation of the model object 'Script'.
The Adapter Factory for the model.
The static methods of this class are made available as functions in the scripts.
Interface that allows listener to be notified of script dependencies (libraries)
The
ScriptDependencyTracker is an interface that script dependency trackers can implement to allow automatic
re-loading if scripts on dependency changesThe
ScriptDependencyTracker.Listener is an interface that needs to be implemented by listeners that want
to be notified about a dependency changeThis Registry is used for a single ScriptEngine instance.
Empty interface to identify scripted handlers
This
ItemChannelLinkProvider keeps ItemChannelLinks provided by scripts during runtime.This
ItemProvider keeps items provided by scripts during runtime.This
MetadataProvider keeps metadata provided by scripts during runtime.This RuleProvider keeps Rules added by scripts during runtime.
This
ThingProvider keeps things provided by scripts during runtime.The script engine is the main entrypoint for openHAB script use.
This class provides the script engine as a console command
This class is used by the ScriptEngineManager to load ScriptEngines.
The ScriptEngineManager provides the ability to load and unload scripts.
A detailed error information for a script
Abstract class for exceptions thrown by the script engine.
The
ScriptExecution allows creating timers for asynchronous script executionThe
ScriptExecution is a wrapper for the ScriptExecution actionsException that is thrown on errors during script execution.
Accessor allowing script engines to lookup presets.
A
ScriptExtensionProvider can provide variable and types on ScriptEngine instance basis.The Factory for the model.
An implementation of the model Factory.
The
ScriptFileWatcher interface needs to be implemented by script file watchers.This class contains custom formatting description.
Use this class to register ide components.
Initialization support for running Xtext languages as language servers.
An implementation of the model object 'Script'.
This class registers all statically available functions as well as the
extensions for specific jvm types, which should only be available in rules,
but not in scripts
The script interpreter handles specific script components, which are not known
to the standard Xbase interpreter.
The
ScriptItemRefresher is responsible for reloading script resources every time an item is added or removed.Infers a JVM model from the source model.
The Package for the model.
Defines literals for the meta objects that represent
each class,
each feature of each class,
each enum,
and each data type
An implementation of the model Package.
Exception that is thrown on errors during script execution.
The
ScriptProfile is generic profile for managing values with scriptsThe
ScriptProfileFactory creates ScriptProfile instancesThis is a marker interface for Script Runtimes.
Use this class to register components to be used at runtime / without the Equinox extension registry.
This class contains custom scoping description.
Utility class for providing easy access to script services.
Initialization support for running Xtext languages
without equinox extension registry
The Switch for the model's inheritance hierarchy.
The methods of this class are made available as functions in the scripts.
The
ScriptTransformationService implements a TransformationService using any available script
languageThe
ScriptTransformationServiceFactory registers a ScriptTransformationService
for each newly added script engine.Calculates the type information used by Xbase to select the correct method during script execution.
Custom validation rules.
This is a
SddpAddonFinder for finding suggested Addons via SDDP.A DTO class containing data from an SDDP device discovery result.
A
SddpDeviceParticipant that is registered as a service is picked up by the SddpDiscoveryService and
can thus be informed when the SDDP service discovers or removes an SddpDevice.A
SddpDiscoveryParticipant that is registered as a service is picked up by the SddpDiscoveryService
and can thus contribute DiscoveryResults from SDDP scans.This is a
DiscoveryService implementation, which can find SDDP devices in the network.Base type for exceptions reporting security concerns.
A representation of the model object 'Selection'.
An implementation of the model object 'Selection'.
The static methods of this class are made available as functions in the scripts.
This class provides predicates that allow filtering item streams with regards to their semantics.
This interface defines a service, which offers functionality regarding semantic tags.
This interface defines the core features of an openHAB semantic tag.
This is a data transfer object that is used to serialize semantic tags.
The
SemanticTagDTOMapper is an utility class to map semantic tags into
semantic tag data transfer objects (DTOs).This is the main implementing class of the
SemanticTag interface.The
SemanticTagProvider is responsible for providing semantic tags.SemanticTagRegistry tracks all SemanticTags from different SemanticTagProviders
and provides access to them.This is a class that gives static access to the semantic tag library.
Interface for a serial port.
Interface for a serial port event.
Interface of a serial port event listener.
Interface of a serial port identifier.
Interface for a serial port manager.
Provides a concrete SerialPort which can handle remote (e.g. via rfc2217) or local ports.
This is a simple data container to keep all details of a service description together.
Guice module that binds openHAB services
A representation of the model object 'Setpoint'.
An implementation of the model object 'Setpoint'.
convenience Rule class with an action handler.
A representation of the model object 'Sitemap'.
The Adapter Factory for the model.
The Factory for the model.
An implementation of the model Factory.
This class contains custom formatting description.
Generates code from your model files on save.
Use this class to register ide components.
Initialization support for running Xtext languages as language servers.
An implementation of the model object 'Sitemap'.
A representation of the model object 'Model'.
An implementation of the model object 'Model'.
The Package for the model.
Defines literals for the meta objects that represent
each class,
each feature of each class,
each enum,
and each data type
An implementation of the model Package.
Use this class to register components to be used at runtime / without the Equinox extension registry.
This class contains custom scoping description.
Initialization support for running Xtext languages
without equinox extension registry
This is a service that provides the possibility to manage subscriptions to sitemaps.
The Switch for the model's inheritance hierarchy.
Custom validation rules.
Delegate SI units to
Units to hide this dependency from the rest of openHAB.This is for an
AudioStream, which size is knownA representation of the model object 'Slider'.
An implementation of the model object 'Slider'.
A representation of the model object 'Specific Unit'.
An implementation of the model object 'Specific Unit'.
A
STTEvent fired when the STTService encounters an error.A
STTEvent fired when the STTService recognizes speech.We do not use the SseBroadcaster as it seems registered SseEventSinks are not removed if the peer terminates the
connection.
SSE Resource for pushing events to currently listening clients.
StartlevelEvents will be delivered through the openHAB event bus if the start level of the system has
changed.This service combines different
ReadyMarkers into a new start level ready marker and thus
lets other services depend on those, without having to know about the single markers.This is a marker interface for all state types.
This is a class which provides all available states and commands (obviously only the enum-based ones with a fixed
name).
This interface must be implemented by all classes that want to be notified about changes in the state of an item.
Interface for builders for
ChannelTypes of kind STATEThe
StateDescription describes restrictions of an item state and gives information how to interpret it.A
StateDescriptionFragment will deliver only the parts of a StateDescription it knows of.Builds a
StateDescriptionFragment with the relevant parts only.Provide a
StateDescriptionFragment for the current StateDescription.Implementations of this service provide strategies for merging info from
different StateDescriptionProviders into one StateDescription.
Describes one possible value an item might have.
A
StateProfile defined the communication for channels of STATE kind.Describes a
StateProfile type.The
Statistics is a class with statistics helper methods.A
Storage is the generic way to store key-value pairs in OHC.This allows the encryption and decryption to be performed before saving to storage.
The
StorageService provides instances of Storages which are
meant as a means for generic storage of key-value pairs.A representation of the model object 'Strategy'.
An implementation of the model object 'Strategy'.
This
InputStream will stream Streams as JSON one item at a time.Streams served by the AudioHTTPServer.
A StringItem can be used for any kind of string to either send or receive
from a device.
This type can be used for items that are dealing with telephony functionality.
Completer for a set of strings.
A representation of the model object 'String Unit'.
An implementation of the model object 'String Unit'.
Static utility methods that are helpful when dealing with strings.
This is a data transfer object that is used to serialize stripped thing types.
The
StrippedThingTypeDTOMapper is a utility class to map things into stripped thing type data transfer
objects (DTOs).A tagging interface for speech-to-text events.
General purpose STT exception
The listener interface for receiving
STTEvent events.This is the interface that a speech-to-text service has to implement.
A handle to a
STTServiceA representation of the model object 'Switch'.
An implementation of the model object 'Switch'.
A SwitchItem represents a normal switch that can be ON or OFF.
Utility class for creation, installation, update and uninstallation of
synthetic bundles for the purpose of testing.
Factory that creates system events.
This is a java bean that is used to serialize/deserialize system event payload.
A representation of the model object 'System On Shutdown Trigger'.
An implementation of the model object 'System On Shutdown Trigger'.
A representation of the model object 'System On Startup Trigger'.
An implementation of the model object 'System On Startup Trigger'.
System profile constants.
A representation of the model object 'System Startlevel Trigger'.
An implementation of the model object 'System Startlevel Trigger'.
A representation of the model object 'System Trigger'.
An implementation of the model object 'System Trigger'.
This is a marker interface for all semantic tag classes.
Common base interface for read and write tasks.
The templates define types of shared, ready to use definitions of automation objects, which
can be instantiated and configured to produce automation instances.
This interface has to be implemented by all providers of
Templates.This interface provides functionality to get available
Templates.TestPortUtil provides helper methods for working with ports in tests.Embedded jetty server used in the tests.
A representation of the model object 'Text'.
An implementation of the model object 'Text'.
A
Thing is a representation of a connected part (e.g. physical device or cloud service) from the real world.Marker interface for Automation Actions with access to a
ThingHandler.Scope definition for a thing action class
The Adapter Factory for the model.
A
ThingAddedEvent notifies subscribers that a thing has been added.This class allows the easy construction of a
Thing instance using the builder pattern.An implementation of
ConfigStatusSource for the Thing entity.This is a data transfer object that is used to serialize things.
The
ThingDTOMapper is a utility class to map things into data transfer objects (DTO).A
ThingEventFactory is responsible for creating thing event instances:
ThingStatusInfoEvent.TYPE
This is a java bean that is used to serialize/deserialize trigger event payload.
The Factory for the model.
ThingFactory helps to create thing based on a given ThingType .An implementation of the model Factory.
ThingFileGenerator is the interface to implement by any file generator for Thing object.This class contains custom formatting description.
Generates code from your model files on save.
A
ThingHandler handles the communication between the openHAB framework and an entity from the real
world, e.g. a physical device, a web service, etc. represented by a Thing.ThingHandlerCallback is callback interface for ThingHandlers.This class provides utility methods related to the
ThingHandler class.Interface for a service that provides access to a
ThingHandler.ThingHelper provides a utility method to create and bind items.Use this class to register ide components.
Initialization support for running Xtext languages as language servers.
ThingManager interface defines methods for managing a Thing.A representation of the model object 'Model'.
An implementation of the model object 'Model'.
The Package for the model.
Defines literals for the meta objects that represent
each class,
each feature of each class,
each enum,
and each data type
An implementation of the model Package.
The
ThingProvider is responsible for providing things.ThingRegistryChangeListener can be implemented to listen for things
being added or removed.A
ThingRemovedEvent notifies subscribers that a thing has been removed.Use this class to register components to be used at runtime / without the Equinox extension registry.
This class provides static methods that can be used in automation rules for
getting thing's status info.
This class contains custom scoping description.
Initialization support for running Xtext languages
without equinox extension registry
A representation of the model object 'Thing State Changed Event Trigger'.
An implementation of the model object 'Thing State Changed Event Trigger'.
A representation of the model object 'Thing State Update Event Trigger'.
An implementation of the model object 'Thing State Update Event Trigger'.
ThingStatus defines possible statuses of a ThingStatusInfo.ThingStatusDetail defines possible status details of a ThingStatusInfo.A
ThingStatusInfo represents status information of a thing which consists of
the status itself
detail of the status
and a description of the status
ThingStatusInfoBuilder is responsible for creating ThingStatusInfos.ThingStatusInfoChangedEvents will be delivered through the openHAB event bus if the status of a
thing has changed.ThingStatusInfoEvents will be delivered through the openHAB event bus if the status of a thing has
been updated.
The
ThingStatusInfoI18nLocalizationService can be used to localize the ThingStatusInfo of a thing
using the I18N mechanism of the openHAB framework.The Switch for the model's inheritance hierarchy.
A
ThingType builder.This is a data transfer object that is used with to serialize thing types.
This OSGi service could be used to localize a
ThingType using the I18N mechanism of the openHAB
framework.The
ThingTypeMigrationService describes a service to change the thing type
of a given Thing.The
ThingTypeProvider is responsible for providing thing types.ThingTypeUID represents a unique identifier for thing types.ThingUID represents a unique identifier for things.A
ThingUpdatedEvent notifies subscribers that a thing has been updated.Custom validation rules.
ThingWebClientUtil provides an utility method to create a valid consumer name for web clients.A builder for
ThreadFactory instances.
This class provides a general mechanism to create thread pools.
A representation of the model object 'Threshold Filter'.
An implementation of the model object 'Threshold Filter'.
A tile can be registered by a UI as a service in order to appear on the main openHAB UI.
This is a data transfer object for a UI tile.
Interface for a component providing UI tiles.
ConditionHandler that evaluates, if the current time satisfies a specified condition.Marker Interface for a
TriggerHandler that contains a time based execution.A representation of the model object 'Time Filter'.
An implementation of the model object 'Time Filter'.
A timer is a handle for a block of code that is scheduled for future execution.
An
TimerEvent is only used to notify rules when timer triggers fire.A representation of the model object 'Timer Trigger'.
An implementation of the model object 'Timer Trigger'.
The
TimeSeries is used to transport a set of states together with their timestamp.
This interface must be implemented by all classes that want to be notified about |@link TimeSeries} updates of an
item.
This interface describes a provider for time zone.
Provides a certificate for the given host name
Implement this interface to request the framework to use a specific certificate for the given host
NOTE: implementations of this interface should be immutable, to guarantee efficient and correct functionality
Provides some TLS validation implementation for the given host name
You should implement one of children of this interface, in order to request the framework to use a specific
implementation for the given host.
Provides a trust manager for the given host name
Implement this interface to request the framework to use a specific trust manager for the given host
NOTE: implementations of this interface should be immutable, to guarantee efficient and correct functionality
A helper to parse a sequence of tokens.
An audio tone synthesizer.
The
TopicEventFilter is a default openHAB EventFilter implementation that ensures filtering
of events based on a single event topic or multiple event topics.The
TopicGlobEventFilter is a default openHAB EventFilter implementation that ensures filtering
of events based on an event topic.The
TopicPrefixEventFilter is a default openHAB EventFilter implementation that ensures filtering
of events based on the prefix of an event topic.The
Transformation is a wrapper for the Transformation class to
allow DSL rules to properly use the TransformationExceptionThis class holds static "action" methods that can be used from within rules to execute
transformations.
The
Transformation encapsulates a transformation configurationThe
TransformationDTO wraps a TransformationThe
TransformationException is a clone of TransformationException to
make it available to DSL rulesA TransformationException is thrown when any step of a transformation went
wrong.
The
TransformationProvider is implemented by providers for transformationsThe
TransformationRegistry is the interface for the transformation registryA TransformationProcessor transforms a given input and returns the transformed
result.
The
TranslationProvider is a service interface for internationalization support within
the platform.The
Translations of a bundle consisting of Translations.TranslationsSections having Translations.TranslationsGroups of
Translations.TranslationsEntrys (key/value pairs).Merges multiple
Translations into one.This interface represents automation
Trigger modules which define what phenomenon will start the execution
of the Rule and trigger it when an exact phenomenon occurs.This class allows the easy construction of a
Trigger instance using the builder pattern.Interface for builders for
ChannelTypes of kind TRIGGERThis is a data transfer object that is used to serialize the respective class.
This is a utility class to convert between the respective object and its DTO.
This Handler interface is used by the RuleManager to set a callback interface to
itself.
This is a callback interface to RuleManager which is used by the
TriggerHandler to notify the RuleManager
about firing of the Trigger.A
TriggerProfile specifies the communication between the framework and the handler for trigger channels.Describes a
TriggerProfile type.This class provides common functionality for creating
Trigger instances by supplying their meta-information.This is a data transfer object that is used to serialize the respective class.
This is a utility class to convert between the respective object and its DTO.
The
TrustAllTrustManager is a "trust all" implementation of X509ExtendedTrustManager.Cache system to avoid requesting
TTSService for the same utterances.General purpose TTS exception
This is the interface that a text-to-speech service has to implement.
This is a parent interface for all states and commands.
This is a helper class that helps parsing a string into an openHAB type (state or command).
A UIComponent represents a piece of UI element for a client frontend to render; it is kept very simple and delegates
the actual rendering and behavior to the frontend.
Provides components (pages, widgets, etc.) at runtime.
A namespace-specific
Registry for UI components.A factory for
UIComponentRegistry instances based on the namespace.Base class for binding related unique identifiers.
A
UIDtoStringConverter is used to create UID string
representations from an input string and vice versa.Utilities for UIDs.
There are situations when item states do not have any defined value.
Provides
Units and the current SystemOfUnits.Delegate common units to
Units to hide this dependency from the rest of openHAB.A utility for parsing dimensions to interface classes of
Quantity and parsing units from format strings.Thrown when a requested format is not supported by an
AudioSource
or AudioSink implementationException that marks that a driver does not allow the specific operation.
A dedicated exception thrown when extracted credentials can not be matched with any authentication provider.
A representation of the model object 'Update Event Trigger'.
An implementation of the model object 'Update Event Trigger'.
The
Upgrader provides an interface for upgrading openHAB configuration files.The
UpgradeTool is a tool for upgrading openHAB to mitigate breaking changesThis is a
UpnpAddonFinder for finding suggested Addons via UPnP.A
UpnpDiscoveryParticipant that is registered as a service is picked up by the UpnpDiscoveryService
and can thus contribute DiscoveryResults from
UPnP scans.The
UpnpIOParticipant is an interface that needs to
be implemented by classes that wants to participate in
UPNP communicationThe
UpnpIOService is an interface that described the
UPNP IO Service.This is an AudioStream from a URL.
This is a
AddonFinder for finding suggested add-ons related to USB devices.This is a data container for information about a USB device and the serial port that can be
used to access the device using a serial interface.
Interface for implementations for discovering serial ports provided by a USB device.
Listener interface for
UsbSerialDiscoverys.A
UsbSerialDiscoveryParticipant that is registered as a component is picked up by the
UsbSerialDiscoveryService and can thus contribute DiscoveryResults from
scans for USB devices with an associated serial port.A user represents an individual, physical person using the system.
An API token represents long-term credentials generated by (or for) a user, giving the bearer access for a certain
scope on behalf of this user.
Credentials which represent a user API token.
Credentials which represent user name and password.
A persistent session for a
ManagedUser, which holds a refresh token used by a client to get short-lived
access tokens for API requests authorization.This is an
Exception implementation for automation objects that retain some additional information.A representation of the model object 'Valid Command'.
A representation of the model object 'Valid Command Id'.
An implementation of the model object 'Valid Command Id'.
An implementation of the model object 'Valid Command'.
A representation of the model object 'Valid Command Number'.
An implementation of the model object 'Valid Command Number'.
A representation of the model object 'Valid Command String'.
An implementation of the model object 'Valid Command String'.
A representation of the model object 'Valid State'.
A representation of the model object 'Valid State Id'.
An implementation of the model object 'Valid State Id'.
An implementation of the model object 'Valid State'.
A representation of the model object 'Valid State Number'.
An implementation of the model object 'Valid State Number'.
A representation of the model object 'Valid State String'.
An implementation of the model object 'Valid State String'.
A representation of the model object 'Valid Trigger'.
A representation of the model object 'Valid Trigger Id'.
An implementation of the model object 'Valid Trigger Id'.
An implementation of the model object 'Valid Trigger'.
A representation of the model object 'Valid Trigger Number'.
An implementation of the model object 'Valid Trigger Number'.
A representation of the model object 'Valid Trigger String'.
An implementation of the model object 'Valid Trigger String'.
ByteBuffer-like interface for working with different types of data stored in byte arrays
The
ValueCache can be used by scripts to share information between subsequent runs of the same script or
between scripts (depending on implementation).A
ValueTypeToStringConverter is used to create a String, Boolean, or BigDecimal from
an input string and vice versa.A representation of the model object 'Variable Declaration'.
An implementation of the model object 'Variable Declaration'.
A representation of the model object 'Video'.
An implementation of the model object 'Video'.
A representation of the model object 'Visibility Rule'.
An implementation of the model object 'Visibility Rule'.
The static methods of this class are made available as functions in the scripts.
This is the interface that a text-to-speech voice has to implement.
This service provides functionality around voice services and is the central service to be used directly by others.
A
Storage implementation which stores it's data in-memory.The
VolatileStorageService returns VolatileStorages
which stores their data in-memory.Define Volumetric Flow Rate type (basic unit is m^3/s).
The
WatchService defines the interface for a general watch service.The
WatchServiceFactory is used to create WatchService instances.The
WebSocketAdapter can be implemented to register an adapter for a websocket connection.Factory class to create Jetty web socket clients
A representation of the model object 'Webview'.
An implementation of the model object 'Webview'.
A representation of the model object 'Widget'.
An implementation of the model object 'Widget'.
Extension of standard
HttpContext interface which allows creation of "sub contexts".Utilities for converting JSON to
ModbusWriteRequestBlueprintPoll task represents Modbus write request
Unlike
PollTask, this does not have to be hashable.Java class for configDescription complex type.
Java class for configDescriptionRef complex type.
Java class for config-descriptions element declaration.
Java class for anonymous complex type.
The
XmlDocumentBundleTracker tracks files in the specified XML folder
of modules and tries to parse them as XML file with the specified
XmlDocumentReader.The
XmlDocumentProvider is responsible managing any created objects
by a ConfigDescriptionReader for a certain module.The
XmlDocumentProviderFactory is responsible to create XmlDocumentProvider instances for any certain
module.The
XmlDocumentReader is an abstract class used to read XML documents
of a certain type and converts them to its according objects.Java class for anonymous complex type.
Java class for parameter complex type.
Java class for parameterGroup complex type.
Java class for parameterType.
Converts XML based
BundleInfo to Translations.The
YamlElement interface must be implemented by any classes that need to be handled by the
YamlModelRepositoryImpl.The
YamlElementName is a required annotation for the inheritors of YamlElement.The
YamlModelListener interface is responsible for managing a particular model type
with data processed from YAML configuration files having a version that is supported by this manager.The
YamlModelRepository defines methods to update elements in a YAML model.
TransformationRegistryinstead