com.google.home.automation

Interfaces

`ActionBehavior`	Represents the behavior of an action.
`ActionCandidate`	Every ActionCandidate should implement this interface
`ActionNodeDsl`	Interface for constructing `Action` nodes and contributing them to an automation flow.
`Automation`	The main representation an automation, composed of various types of Automation nodes, including `Starter` instances, `Condition` instances, `Action` instances, and more.
`AutomationFlowBuilder`	Interface to build an automation flow.
`AutomationFlowContributor`	Interface for contributing nodes to an automation flow builder (e.g. sequential, parallel, etc).
`BaseAutomation`	Interface that is common between `Automation` and `DraftAutomation`.
`ConditionNodeDsl`	Interface for constructing `Condition` nodes and contributing them to an automation flow.
`Constraint`	Constraints on a trait attribute, command parameter, or event field.
`DelayNodeDsl`	Interface for constructing `Delay` nodes and contributing them to an automation flow.
`Expression`	An expression which evaluates to a value.
`HasAutomations`	Interface that allows for `Automation` creation, retrieval, update, and deletion operations.
`HasCandidates`	Interface that provides discovery functions.
`HasOutput`	A node that can produce output, such as `Starter` or `Action`.
`ManualStarterNodeDsl`	Interface for constructing `ManualStarter` nodes and contributing them to an automation flow.
`MutableAutomation`	Mutable attributes for an `Automation`.
`NodeCandidate`	The interface that every automation candidate should implement.
`ParallelNodeDsl`	Interface for constructing Parallel nodes and contributing them to an automation flow.
`SelectNodeDsl`	Interface for constructing Select nodes and contributing them to an automation flow.
`SequentialDsl`	Interface for constructing Sequential nodes and contributing them to an automation flow.
`StarterCandidate`	Every StarterCandidate should implement this interface
`StarterNodeDsl`	Interface for constructing `Starter` nodes and adding them to an automation flow.
`StateReaderCandidate`	Every StateReaderCandidate should implement this interface
`StateReaderNodeDsl`	Interface for constructing `StateReader` nodes and contributing them to an automation flow.
`SuppressionNodeDsl`	Interface for constructing `Suppression` nodes and contributing them to an automation flow.
`UnsupportedCandidateReason`	Reasons why a candidate node is not supported.

Classes

`Action`	Represents a command that the automation can issue, such as turning on a device, or a change to the value of a trait attribute, such as increasing a temperature threshold.
`ActionBuilder`	Type-safe builder that builds an `Action` node.
`And`	The logical AND operator.
`AttributeDetails`	Metadata pertaining to a trait attribute.
`AttributeToUpdate`	Represents a single attribute to update.
`AutomationBuilder`	Type-safe builder that builds an `Automation` node.
`AutomationTooLarge`	The automation's serialized form is larger than what is allowed by the abuse prevention config for the calling application.
`Between`	The between operator, which evaluates to `true` when `operand1` is between `operand2` and `operand3`.
`BetweenTimes`	The between times operator, which evaluates to `true` when `operand1` is between `operand2` and `operand3`.
`BinaryExpression`	Represents a binary expression with two operands: "`operand1` `operator` `operand2`".
`BitmapConstraint`	Represents constraints on a bitmap.
`BlockedAction`	The action could impact the safety, security, or privacy of a household.
`BooleanConstraint`	Constrains a field to boolean values.
`ByteConstraint`
`CombinedBitsDescriptor`	Represents a group of bits in a bitmap.
`Command`	A trait command used in an automation `Action`.
`CommandCandidate`	Represents automation candidate node corresponding to a command.
`CommandFieldDetails`	A parameter belonging to a `Command`.
`Comprehension`	Represents list comprehension expressions.
`Condition`	A logical state that controls whether an automation that has been triggered by a `Starter` or `StateReader`" should continue or stop executing.
`ConditionBuilder`	Type-safe builder that builds a `Condition` node.
`ConditionDurationOutOfRange`	The condition duration is outside the accepted range of 1-30 minutes.
`Constant`	Represents a constant.
`ConstraintUnit`	Class representing a unit of measurement.
`Delay`	A `Node` that provides the ability to pause for a specified amount of time.
`DelayDurationOutOfRange`	Delay duration is outside the accepted range of 5 seconds to 24 hours.
`Divide`	The DIVIDE operator, which calculates `operand1 / operand2`.
`DuplicateStarterNode`	The starter is listening to the same trait change or event as existing starter nodes.
`EnumConstraint`	Represents possible values a field can take.
`Equals`	The equality operator, which evaluates to `true` when `operand1` equals `operand2`.
`EventCandidate`	Represents automation candidate nodes corresponding to an event.
`EventFieldDetails`	A field that belongs to an Event.
`ExpressionWithId`	Represents an expression with random UUID.
`FieldDetails`	Describes a Field with additional details, in addition to information from interface `Field`.
`FieldSelect`	Select field(s) from a struct.
`GreaterThan`	The greater-than operator, which evaluates to `true` when `operand1` `>` `operand2`.
`GreaterThanOrEquals`	The greater-than-or-equal-to operator, which evaluates to `true` when `operand1` `>=` `operand2`.
`InvalidArgumentCount`	The expression has an invalid argument count.
`InvalidArgumentsForOperator`	Represents the data type of a value.
`InvalidCommand`	The command ID is not found in the command schema.
`InvalidConditionType`	The condition type is not valid.
`InvalidDuration`	The duration is invalid.
`InvalidEntity`	The Entity (ID or name) does not exist or belong to the user.
`InvalidEvent`	The event ID is not found in the event schema.
`InvalidField`	The FIELD_SELECT expression uses an invalid field.
`InvalidNullParameterValue`	The parameter value must not be null.
`InvalidOperand`	The expression uses an invalid operand.
`InvalidParameter`	The parameter name is not found in the behavior schema.
`InvalidParameterType`	The parameter type is not valid.
`InvalidReference`	The Reference is not valid.
`InvalidTrait`	The trait ID is not found in the trait schema.
`InvalidValue`	The value is invalid.
`LessThan`	The less-than operator, which evaluates to `true` when `operand1` `<` `operand2`.
`LessThanOrEquals`	The less-than-or-equal-to operator, which evaluates to `true` when `operand1` `<=` `operand2`.
`ListAllMatch`	Represents the "all match" operation on a list expression.
`ListAnyMatch`	Represents the "any match" operation on a list expression.
`ListConstraint`	Represents constraints on elements of a list.
`ListContains`	Represents the "contains" operation on a list expression.
`ListFilter`	Represents the "filter" operation on a list expression.
`ListGet`	Represents the "get" operation on a list expression.
`ListIn`	Represents the "in" operation on a list expression.
`ListMap`	Represents the map operation on a list expression.
`ListNoneMatch`	Represents the "none match" operation on a list expression.
`ListSize`	Represents the "size" operation on a list expression.
`ManualStarter`	A starter that allows the user to manually activate an automation.
`Minus`	The MINUS operator, which calculates `operand1 - operand2`.
`MisplacedSelectFlow`	The select flow node must be the first node in an automation.
`MisplacedStarterNode`	The starter node must be the first node in an automation or in a select flow.
`MissingPresenceSensingSetup`	Candidate is not supported due to missing presence sensing setup.
`MissingRequiredFields`	Missing required field(s) in the automation graph.
`MissingRequiredParameters`	Required parameters not set.
`MissingStarterNode`	The node cannot be reached without a preceding starter node.
`MissingStructureAddressSetup`	Candidate is not supported due to missing structure address setup.
`MissingSubscription`	Candidate is not supported due to missing subscription setup.
`MultipleManualStarters`	The automation has more than one manual starter node.
`Multiply`	The MULTIPLY operator, which calculates `operand1 * operand2`.
`Node`	An Automation node.
`Not`	The logical NOT operator.
`NotEquals`	The not-equals operator, which evaluates to `true` when `operand1` is not equal to `operand2`.
`NumberRangeConstraint`	Represents a range of numbers.
`NumberSetConstraint`	Represents a set of numbers.
`Or`	The logical OR operator.
`OutputNotAccessible`	An output reference is not accessible.
`OutputReinitialized`	An output variable has been reinitialized in multiple nodes.
`OutputTypeMismatch`	An output variable has been defined in multiple nodes with different types.
`ParallelFlow`	A set of one or more Automation nodes that execute in parallel.
`ParallelFlowBuilder`	Type-safe builder that builds a `ParallelFlow` node.
`Parameter`	A command parameter.
`ParametersBuilder`	Type-safe builder that builds a `Parameter`.
`Plus`	The PLUS operator, which calculates `operand1 + operand2`.
`ReadOnlyAttribute`	The attribute is not modifiable without a command, by write.
`Reference`	Represents a reference to a previously defined node in the automation graph, or an list element for list comprehension expression .
`ReferenceDeclaration`	Represents a reference declaration.
`SelectFlow`	A `Node` that, when it contains more than one `Node`, allows only one `Node` to execute.
`SelectFlowBuilder`	Type-safe builder that builds a `SelectFlow` node.
`SequentialFlow`	A set of one or more Automation nodes that execute sequentially.
`SequentialFlowBuilder`	Type-safe builder that builds a `SequentialFlow` Node.
`Starter`	Defines the initial triggers that activate an automation, such as a change to a trait.
`StateReader`	A class that accesses a trait's state.
`StringConstraint`	Represents string constraints, including constraints on length, and specific allowed and disallowed values.
`StructConstraint`	Represents constraints on individual fields of a struct.
`Suppression`	Terminates execution of all the following nodes if the automation is triggered again within the specified time range.
`SuppressionDurationOutOfRange`	The suppression duration is outside the accepted range of 5 seconds to 24 hours.
`TernaryExpression`	Represents a ternary expression with three operands".
`TooManyNodes`	The automation has more nodes than allowed by the abuse prevention config for the calling application.
`TooManyOperations`	The expression has more operations than allowed by the abuse prevention config for the calling application.
`TraitAttributesCandidate`	Represents automation candidate nodes corresponding to a trait's attributes.
`TypedExpression`	An expression with an associated type: T.
`UnaryExpression`	Represents a unary expression with one operand: "`operator` `operand`".
`UnknownCommand`	Represents an unknown Command.
`UnknownDeviceType`	Represents an unknown DeviceType.
`UnknownDeviceType.UnknownDeviceTypeFactory`
`UnknownEntity`	An unrecognized entity.
`UnknownEvent`	Represents an unknown Event.
`UnknownEvent.UnknownEventFactory`
`UnknownExpression`	Represents an unknown expression.
`UnknownField`	Represents an unknown field, which can be an attribute, or parameter, or a field in a struct, etc.
`UnknownIssue`	Default validation issue type.
`UnknownNode`	An unknown node type converted from ADM proto.
`UnknownTrait`	Represents an unknown Trait.
`UnknownTrait.UnknownTraitFactory`
`UnknownValue`	Represents an unknown value.
`UnsubscribableAttribute`	The attribute is not subscribable thus cannot be used in a starter.
`UnsupportedActionBehavior`	The entity behavior type is not supported by the action node.
`UnsupportedEntityCommand`	The command is not supported by the entity.
`UnsupportedEntityEvent`	The event is not supported by the entity.
`UnsupportedEntityParameter`	The parameter is not supported by the entity.
`UnsupportedEntityParameterValue`	The parameter value is not supported by the entity.
`UnsupportedEntityTrait`	The trait is not supported by the entity.
`UnsupportedEntityType`	The entity type is not supported by the entity.
`UnsupportedNodeOutput`	This type of node does not produce output.
`UnsupportedOperator`	The expression uses an unsupported operator.
`UnsupportedStarterBehavior`	The entity behavior type is not supported by the starter node.
`UnsupportedStateReaderBehavior`	The entity behavior type is not supported by the state reader node.
`UnsupportedSubNodeType`	The sub-node type is not allowed inside the parent node.
`Update`	Trait attribute update used in automation action.
`Updater`	Trait attribute updater that builds the list of attributes to be updated.
`ValidationIssue`	The base class for validation issues.

Annotations

AutomationDsl

Enums

`BaseUnit`	Represents the base unit of a measurement.
`JoinSemanticType`	Ways of coordinating the execution of multiple concurrent operations.
`MissingPresenceSensingSetup.SetupType`	Type of presence sensing setup that is missing.
`ValidationIssueSeverity`	Validation Error Severity Type.
`ValidationIssueType`	Validation Issue Type

Type aliases

DraftAutomation

Interface that represents the user-specifiable parts of the Automation.

Top-level functions summary

`BaseAutomation`	`automation(block: AutomationBuilder.() -> Unit)` Build an `Automation` from an `AutomationBuilder`.
`TypedExpression<Duration>`	`constant(constantValue: Duration)` Represents a constant of `Duration` value.
`TypedExpression<LocalTime>`	`constant(constantValue: LocalTime)` Represents a constant of `LocalTime` value.
`TypedExpression<U>`	`<T : Any?, U : Any?> fieldSelect( selectFrom: TypedExpression<T?>, selectedField: Field )` Type-safe builder function that builds a `FieldSelect` expression.
`TypedExpression<Boolean>`	`not(expr: TypedExpression<Boolean>)` Allows the use of the `Not` operator.
`ParallelFlow`	`parallel(block: ParallelFlowBuilder.() -> Unit)` Build a `ParallelFlow` node from a `ParallelFlowBuilder`.
`ParallelFlow`	`parallel(nodes: List<Node>, joinSemantic: JoinSemanticType)` Build a `ParallelFlow` from a list of `Node` instances.
`SelectFlow`	`select(block: SelectFlowBuilder.() -> Unit)` Build a `SelectFlow` from a `SelectFlowBuilder`.
`SelectFlow`	`select(nodes: List<Node>)` Build a `SelectFlow` from a list of `Node` instances.
`SequentialFlow`	`sequential(block: SequentialFlowBuilder.() -> Unit)` Build a `SequentialFlow` node from a `SequentialFlowBuilder`.
`SequentialFlow`	`sequential(nodes: List<Node>)` Build a `SequentialFlow` from a list of `Node` instances.
`TypedExpression<T>`	`<T : Event> starter(structure: Structure, event: EventFactory<T>)` Build a `Starter` from a `Structure` and a `Event`.
`TypedExpression<T>`	`<T : Trait> starter(structure: Structure, trait: TraitFactory<T>)` Build a `Starter` from a `Structure` and a `Trait`.
`TypedExpression<T>`	`<T : Event> starter( device: HomeDevice, deviceType: DeviceTypeFactory<DeviceType>, event: EventFactory<T> )` Build a `Starter` from a Device and `Event`.
`TypedExpression<T>`	`<T : Trait> starter( device: HomeDevice, deviceType: DeviceTypeFactory<DeviceType>, trait: TraitFactory<T> )` Create a `Starter` from a Device and a `Trait`.
`TypedExpression<T>`	`<T : Event> starter( structure: Structure, event: EventFactory<T>, block: ParametersBuilder.() -> Unit )` Build a `Starter` from an `Event` along with its parameters.
`TypedExpression<T>`	`<T : Event> starter( device: HomeDevice, deviceType: DeviceTypeFactory<DeviceType>, event: EventFactory<T>, block: ParametersBuilder.() -> Unit )` Build a `Starter` from a Device and `Event` along with its parameters.
`TypedExpression<T>`	`<T : Trait> stateReader(structure: Structure, trait: TraitFactory<T>)` Build a `StateReader` from a `Trait`.
`TypedExpression<T>`	`<T : Trait> stateReader( device: HomeDevice, deviceType: DeviceTypeFactory<DeviceType>, trait: TraitFactory<T> )` Build a `StateReader` from a Device and `Trait`.

Extension functions summary

`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<List<T>?>.all( body: (TypedExpression<T>) -> TypedExpression<Boolean> )` An extension function of TypedExpression?> that performs All match operation on list using the lambda condition.
`infix TypedExpression<Boolean>`	`TypedExpression<Boolean>.and(other: TypedExpression<Boolean>)` Allows the use of the `And` operator in an infix manner.
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<List<T>?>.any( body: (TypedExpression<T>) -> TypedExpression<Boolean> )` An extension function of TypedExpression?> that performs Any match operation on list using the lambda condition.
`TypedExpression<Boolean>`	`TypedExpression<LocalTime?>.between(param0: LocalTime, param1: LocalTime)`
`TypedExpression<Boolean>`	`TypedExpression<LocalTime?>.between( param0: LocalTime, param1: TypedExpression<LocalTime?> )`
`TypedExpression<Boolean>`	`TypedExpression<LocalTime?>.between( param0: TypedExpression<LocalTime?>, param1: LocalTime )`
`TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.between( param0: TypedExpression<T>, param1: TypedExpression<T> )`
`TypedExpression<Boolean>`	`TypedExpression<LocalTime?>.between( param0: TypedExpression<LocalTime?>, param1: TypedExpression<LocalTime?> )`
`TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.between( param0: TypedExpression<T>, param1: T )`
`TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.between(param0: T, param1: T)`
`TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.between( param0: T, param1: TypedExpression<T> )`
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<List<T>?>.contains(constant: T)` An extension function of TypedExpression?> that performs the `Contains` operation on a constant using a list.
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<List<T>?>.contains(element: TypedExpression<T>)` An extension function of TypedExpression?> that performs the `Contains` operation on an expression using a list.
`operator TypedExpression<UByte>`	`TypedExpression<UByte?>.div(param0: TypedExpression<UByte?>)`
`operator TypedExpression<UInt>`	`TypedExpression<UInt?>.div(param0: TypedExpression<UInt?>)`
`operator TypedExpression<ULong>`	`TypedExpression<ULong?>.div(param0: TypedExpression<ULong?>)`
`operator TypedExpression<UShort>`	`TypedExpression<UShort?>.div(param0: TypedExpression<UShort?>)`
`operator TypedExpression<T>`	`<T : Number?> TypedExpression<T>.div(param0: TypedExpression<T>)`
`operator TypedExpression<UByte>`	`TypedExpression<UByte?>.div(param0: UByte)`
`operator TypedExpression<UInt>`	`TypedExpression<UInt?>.div(param0: UInt)`
`operator TypedExpression<ULong>`	`TypedExpression<ULong?>.div(param0: ULong)`
`operator TypedExpression<UShort>`	`TypedExpression<UShort?>.div(param0: UShort)`
`operator TypedExpression<T>`	`<T : Number?> TypedExpression<T>.div(param0: T)`
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<T>.equals(param0: TypedExpression<T>)`
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<T>.equals(param0: T)`
`infix TypedExpression<List<T>?>`	`<T : Any?> TypedExpression<List<T>?>.filter( body: (TypedExpression<T>) -> TypedExpression<Boolean> )` An extension function of TypedExpression?> that performs Filter operation on list using the lambda condition.
`operator TypedExpression<T?>`	`<T : Any?> TypedExpression<List<T>?>.get(constant: Int)` An extension function of TypedExpression?> that performs the `Get` operation on a constant using a list.
`operator TypedExpression<T?>`	`<T : Any?> TypedExpression<List<T>?>.get(constant: UInt)` An extension function of TypedExpression?> that performs the `Get` operation on a constant using a list.
`operator TypedExpression<T?>`	`<T : Any?> TypedExpression<List<T>?>.get(index: TypedExpression<Int?>)` An extension function of TypedExpression?> that performs the `Get` operation on an expression using a list.
`operator TypedExpression<T?>`	`<T : Any?> TypedExpression<List<T>?>.get(index: TypedExpression<UInt?>)` An extension function of TypedExpression?> that performs the `Get` operation on an expression using a list.
`infix TypedExpression<Boolean>`	`TypedExpression<Duration?>.greaterThan(param0: Duration)`
`infix TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.greaterThan( param0: TypedExpression<T> )`
`infix TypedExpression<Boolean>`	`TypedExpression<Duration?>.greaterThan( param0: TypedExpression<Duration?> )`
`infix TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.greaterThan(param0: T)`
`infix TypedExpression<Boolean>`	`TypedExpression<Duration?>.greaterThanOrEquals(param0: Duration)`
`infix TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.greaterThanOrEquals( param0: TypedExpression<T> )`
`infix TypedExpression<Boolean>`	`TypedExpression<Duration?>.greaterThanOrEquals( param0: TypedExpression<Duration?> )`
`infix TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.greaterThanOrEquals(param0: T)`
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<T>.inList( listExpression: TypedExpression<List<T>?> )` An extension function of Expression that performs In operation on an expression list
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<T>.inList(list: List<T>)` An extension function of Constant that performs In operation on a constant list
`infix TypedExpression<Boolean>`	`TypedExpression<Duration?>.lessThan(param0: Duration)`
`infix TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.lessThan( param0: TypedExpression<T> )`
`infix TypedExpression<Boolean>`	`TypedExpression<Duration?>.lessThan(param0: TypedExpression<Duration?>)`
`infix TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.lessThan(param0: T)`
`infix TypedExpression<Boolean>`	`TypedExpression<Duration?>.lessThanOrEquals(param0: Duration)`
`infix TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.lessThanOrEquals( param0: TypedExpression<T> )`
`infix TypedExpression<Boolean>`	`TypedExpression<Duration?>.lessThanOrEquals( param0: TypedExpression<Duration?> )`
`infix TypedExpression<Boolean>`	`<T : Comparable<*>?> TypedExpression<T>.lessThanOrEquals(param0: T)`
`infix TypedExpression<List<U>?>`	`<T : Any?, U : Any?> TypedExpression<List<T>?>.map( body: (TypedExpression<T>) -> TypedExpression<U> )` An extension function of TypedExpression?> that performs Map operation on list using the lambda condition.
`operator TypedExpression<LocalTime>`	`TypedExpression<LocalTime?>.minus(param0: Duration)`
`operator TypedExpression<Duration>`	`TypedExpression<Duration?>.minus(param0: Duration)`
`operator TypedExpression<UByte>`	`TypedExpression<UByte?>.minus(param0: TypedExpression<UByte?>)`
`operator TypedExpression<UInt>`	`TypedExpression<UInt?>.minus(param0: TypedExpression<UInt?>)`
`operator TypedExpression<ULong>`	`TypedExpression<ULong?>.minus(param0: TypedExpression<ULong?>)`
`operator TypedExpression<UShort>`	`TypedExpression<UShort?>.minus(param0: TypedExpression<UShort?>)`
`operator TypedExpression<T>`	`<T : Number?> TypedExpression<T>.minus(param0: TypedExpression<T>)`
`operator TypedExpression<LocalTime>`	`TypedExpression<LocalTime?>.minus(param0: TypedExpression<Duration?>)`
`operator TypedExpression<Duration>`	`TypedExpression<Duration?>.minus(param0: TypedExpression<Duration?>)`
`operator TypedExpression<UByte>`	`TypedExpression<UByte?>.minus(param0: UByte)`
`operator TypedExpression<UInt>`	`TypedExpression<UInt?>.minus(param0: UInt)`
`operator TypedExpression<ULong>`	`TypedExpression<ULong?>.minus(param0: ULong)`
`operator TypedExpression<UShort>`	`TypedExpression<UShort?>.minus(param0: UShort)`
`operator TypedExpression<T>`	`<T : Number?> TypedExpression<T>.minus(param0: T)`
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<List<T>?>.none( body: (TypedExpression<T>) -> TypedExpression<Boolean> )` An extension function of TypedExpression?> that performs None match operation on list using the lambda condition.
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<T>.notEquals(param0: TypedExpression<T>)`
`infix TypedExpression<Boolean>`	`<T : Any?> TypedExpression<T>.notEquals(param0: T)`
`infix TypedExpression<Boolean>`	`TypedExpression<Boolean>.or(other: TypedExpression<Boolean>)` Allows the use of the `Or` operator in an infix manner.
`operator TypedExpression<LocalTime>`	`TypedExpression<LocalTime?>.plus(param0: Duration)`
`operator TypedExpression<Duration>`	`TypedExpression<Duration?>.plus(param0: Duration)`
`operator TypedExpression<String>`	`TypedExpression<String?>.plus(param0: String)`
`operator TypedExpression<UByte>`	`TypedExpression<UByte?>.plus(param0: TypedExpression<UByte?>)`
`operator TypedExpression<UInt>`	`TypedExpression<UInt?>.plus(param0: TypedExpression<UInt?>)`
`operator TypedExpression<ULong>`	`TypedExpression<ULong?>.plus(param0: TypedExpression<ULong?>)`
`operator TypedExpression<UShort>`	`TypedExpression<UShort?>.plus(param0: TypedExpression<UShort?>)`
`operator TypedExpression<T>`	`<T : Number?> TypedExpression<T>.plus(param0: TypedExpression<T>)`
`operator TypedExpression<String>`	`TypedExpression<String?>.plus(param0: TypedExpression<String?>)`
`operator TypedExpression<LocalTime>`	`TypedExpression<LocalTime?>.plus(param0: TypedExpression<Duration?>)`
`operator TypedExpression<Duration>`	`TypedExpression<Duration?>.plus(param0: TypedExpression<Duration?>)`
`operator TypedExpression<UByte>`	`TypedExpression<UByte?>.plus(param0: UByte)`
`operator TypedExpression<UInt>`	`TypedExpression<UInt?>.plus(param0: UInt)`
`operator TypedExpression<ULong>`	`TypedExpression<ULong?>.plus(param0: ULong)`
`operator TypedExpression<UShort>`	`TypedExpression<UShort?>.plus(param0: UShort)`
`operator TypedExpression<T>`	`<T : Number?> TypedExpression<T>.plus(param0: T)`
`operator TypedExpression<UByte>`	`TypedExpression<UByte?>.times(param0: TypedExpression<UByte?>)`
`operator TypedExpression<UInt>`	`TypedExpression<UInt?>.times(param0: TypedExpression<UInt?>)`
`operator TypedExpression<ULong>`	`TypedExpression<ULong?>.times(param0: TypedExpression<ULong?>)`
`operator TypedExpression<UShort>`	`TypedExpression<UShort?>.times(param0: TypedExpression<UShort?>)`
`operator TypedExpression<T>`	`<T : Number?> TypedExpression<T>.times(param0: TypedExpression<T>)`
`operator TypedExpression<UByte>`	`TypedExpression<UByte?>.times(param0: UByte)`
`operator TypedExpression<UInt>`	`TypedExpression<UInt?>.times(param0: UInt)`
`operator TypedExpression<ULong>`	`TypedExpression<ULong?>.times(param0: ULong)`
`operator TypedExpression<UShort>`	`TypedExpression<UShort?>.times(param0: UShort)`
`operator TypedExpression<T>`	`<T : Number?> TypedExpression<T>.times(param0: T)`
`TypedExpression<Byte?>`	`TypedExpression<Short?>.toByte()`
`TypedExpression<Byte?>`	`TypedExpression<Int?>.toByte()`
`TypedExpression<Byte?>`	`TypedExpression<Long?>.toByte()`
`TypedExpression<Double?>`	`TypedExpression<Float?>.toDouble()`
`TypedExpression<Float?>`	`TypedExpression<Double?>.toFloat()`
`TypedExpression<Int?>`	`TypedExpression<Byte?>.toInt()`
`TypedExpression<Int?>`	`TypedExpression<Short?>.toInt()`
`TypedExpression<Int?>`	`TypedExpression<Long?>.toInt()`
`TypedExpression<Long?>`	`TypedExpression<Byte?>.toLong()`
`TypedExpression<Long?>`	`TypedExpression<Short?>.toLong()`
`TypedExpression<Long?>`	`TypedExpression<Int?>.toLong()`
`TypedExpression<Short?>`	`TypedExpression<Byte?>.toShort()`
`TypedExpression<Short?>`	`TypedExpression<Int?>.toShort()`
`TypedExpression<Short?>`	`TypedExpression<Long?>.toShort()`
`TypedExpression<UByte?>`	`TypedExpression<UShort?>.toUByte()`
`TypedExpression<UByte?>`	`TypedExpression<UInt?>.toUByte()`
`TypedExpression<UByte?>`	`TypedExpression<ULong?>.toUByte()`
`TypedExpression<UInt?>`	`TypedExpression<UByte?>.toUInt()`
`TypedExpression<UInt?>`	`TypedExpression<UShort?>.toUInt()`
`TypedExpression<UInt?>`	`TypedExpression<ULong?>.toUInt()`
`TypedExpression<ULong?>`	`TypedExpression<UByte?>.toULong()`
`TypedExpression<ULong?>`	`TypedExpression<UShort?>.toULong()`
`TypedExpression<ULong?>`	`TypedExpression<UInt?>.toULong()`
`TypedExpression<UShort?>`	`TypedExpression<UByte?>.toUShort()`
`TypedExpression<UShort?>`	`TypedExpression<UInt?>.toUShort()`
`TypedExpression<UShort?>`	`TypedExpression<ULong?>.toUShort()`

Extension properties summary

TypedExpression<Int>

TypedExpression<List<*>?>.size

An extension property of TypedExpression?> that performs the Size operation on list.

Top-level functions

automation

fun automation(block: AutomationBuilder.() -> Unit): BaseAutomation

Build an Automation from an AutomationBuilder.

Parameters
`block: AutomationBuilder.() -> Unit`	The `AutomationBuilder` used to build the `Automation`.

constant

fun constant(constantValue: Duration): TypedExpression<Duration>

Represents a constant of Duration value.

constant

fun constant(constantValue: LocalTime): TypedExpression<LocalTime>

Represents a constant of LocalTime value.

fieldSelect

fun <T : Any?, U : Any?> fieldSelect(
    selectFrom: TypedExpression<T?>,
    selectedField: Field
): TypedExpression<U>

Type-safe builder function that builds a FieldSelect expression. DO NOT directly use this function to build a FieldSelect expression. Instead, use the extension functions in the generated code and the Automation DSL to build condition expressions.

Parameters
`selectFrom: TypedExpression<T?>`	The expression to select from.
`selectedField: Field`	The selected `Field`.

not

fun not(expr: TypedExpression<Boolean>): TypedExpression<Boolean>

Allows the use of the Not operator.

parallel

fun parallel(block: ParallelFlowBuilder.() -> Unit): ParallelFlow

Build a ParallelFlow node from a ParallelFlowBuilder.

Parameters
`block: ParallelFlowBuilder.() -> Unit`	The `ParallelFlowBuilder` used to build the `ParallelFlow`.

parallel

fun parallel(
    nodes: List<Node>,
    joinSemantic: JoinSemanticType = JoinSemanticType.JsWhenAllFinished
): ParallelFlow

Build a ParallelFlow from a list of Node instances.

Parameters
`nodes: List<Node>`	The `Node` instances to include in the `ParallelFlow`.
`joinSemantic: JoinSemanticType = JoinSemanticType.JsWhenAllFinished`	The type of join to use in the `ParallelFlow`.

select

fun select(block: SelectFlowBuilder.() -> Unit): SelectFlow

Build a SelectFlow from a SelectFlowBuilder.

Parameters
`block: SelectFlowBuilder.() -> Unit`	The `SelectFlowBuilder` used to build the `SelectFlow`.

select

fun select(nodes: List<Node>): SelectFlow

Build a SelectFlow from a list of Node instances.

Parameters
`nodes: List<Node>`	The nodes to include in the `SelectFlow`.

sequential

fun sequential(block: SequentialFlowBuilder.() -> Unit): SequentialFlow

Build a SequentialFlow node from a SequentialFlowBuilder.

Parameters
`block: SequentialFlowBuilder.() -> Unit`	The `SequentialFlowBuilder` used to build the `SequentialFlow`.

sequential

fun sequential(nodes: List<Node>): SequentialFlow

Build a SequentialFlow from a list of Node instances.

Parameters
`nodes: List<Node>`	The nodes to include in the `SequentialFlow`.

starter

fun <T : Event> starter(structure: Structure, event: EventFactory<T>): TypedExpression<T>

Build a Starter from a Structure and a Event.

Parameters
`structure: Structure`	The `Structure` associated with the `Starter`.
`event: EventFactory<T>`	The `Event` associated with the `Starter`.

starter

fun <T : Trait> starter(structure: Structure, trait: TraitFactory<T>): TypedExpression<T>

Build a Starter from a Structure and a Trait.

Parameters
`structure: Structure`	The `Structure` associated with the `Starter`.
`trait: TraitFactory<T>`	The `Trait` associated with the `Starter`.

starter

fun <T : Event> starter(
    device: HomeDevice,
    deviceType: DeviceTypeFactory<DeviceType>,
    event: EventFactory<T>
): TypedExpression<T>

Build a Starter from a Device and Event.

Parameters
`device: HomeDevice`	The Device associated with the `Starter`.
`deviceType: DeviceTypeFactory<DeviceType>`	The `DeviceType` associated with the `Starter`.
`event: EventFactory<T>`	The `Event` associated with the `Starter`.

starter

fun <T : Trait> starter(
    device: HomeDevice,
    deviceType: DeviceTypeFactory<DeviceType>,
    trait: TraitFactory<T>
): TypedExpression<T>

Create a Starter from a Device and a Trait.

Parameters
`device: HomeDevice`	The `HomeDevice` associated with the `Starter`.
`deviceType: DeviceTypeFactory<DeviceType>`	The `DeviceType` associated with the `Starter`.
`trait: TraitFactory<T>`	The `Trait` associated with the `Starter`.

Returns
`TypedExpression<T>`	A `Starter` instance.

starter

fun <T : Event> starter(
    structure: Structure,
    event: EventFactory<T>,
    block: ParametersBuilder.() -> Unit
): TypedExpression<T>

Build a Starter from an Event along with its parameters.

Parameters
`structure: Structure`	The `Structure` associated with the `Starter`.
`event: EventFactory<T>`	The `Event` associated with the `Starter`.
`block: ParametersBuilder.() -> Unit`	The parameter associated with the `Starter`.

starter

fun <T : Event> starter(
    device: HomeDevice,
    deviceType: DeviceTypeFactory<DeviceType>,
    event: EventFactory<T>,
    block: ParametersBuilder.() -> Unit
): TypedExpression<T>

Build a Starter from a Device and Event along with its parameters.

Parameters
`device: HomeDevice`	The Device associated with the `Starter`.
`deviceType: DeviceTypeFactory<DeviceType>`	The `DeviceType` associated with the `Starter`.
`event: EventFactory<T>`	The `Event` associated with the `Starter`.
`block: ParametersBuilder.() -> Unit`	The parameter associated with the `Starter`.

stateReader

fun <T : Trait> stateReader(structure: Structure, trait: TraitFactory<T>): TypedExpression<T>

Build a StateReader from a Trait.

Parameters
`structure: Structure`	The `Structure` associated with the `StateReader`.
`trait: TraitFactory<T>`	The `Trait` associated with the `StateReader`.

stateReader

fun <T : Trait> stateReader(
    device: HomeDevice,
    deviceType: DeviceTypeFactory<DeviceType>,
    trait: TraitFactory<T>
): TypedExpression<T>

Build a StateReader from a Device and Trait.

Parameters
`device: HomeDevice`	The Device associated with the `StateReader`.
`deviceType: DeviceTypeFactory<DeviceType>`	The `DeviceType` associated with the `StateReader`.
`trait: TraitFactory<T>`	The `Trait` associated with the `StateReader`.

Extension functions

all

infix fun <T : Any?> TypedExpression<List<T>?>.all(
    body: (TypedExpression<T>) -> TypedExpression<Boolean>
): TypedExpression<Boolean>

An extension function of TypedExpression?> that performs All match operation on list using the lambda condition.

and

infix fun TypedExpression<Boolean>.and(other: TypedExpression<Boolean>): TypedExpression<Boolean>

Allows the use of the And operator in an infix manner.

any

infix fun <T : Any?> TypedExpression<List<T>?>.any(
    body: (TypedExpression<T>) -> TypedExpression<Boolean>
): TypedExpression<Boolean>

An extension function of TypedExpression?> that performs Any match operation on list using the lambda condition.

between

fun TypedExpression<LocalTime?>.between(param0: LocalTime, param1: LocalTime): TypedExpression<Boolean>

between

fun TypedExpression<LocalTime?>.between(
    param0: LocalTime,
    param1: TypedExpression<LocalTime?>
): TypedExpression<Boolean>

between

fun TypedExpression<LocalTime?>.between(
    param0: TypedExpression<LocalTime?>,
    param1: LocalTime
): TypedExpression<Boolean>

between

fun <T : Comparable<*>?> TypedExpression<T>.between(
    param0: TypedExpression<T>,
    param1: TypedExpression<T>
): TypedExpression<Boolean>

between

fun TypedExpression<LocalTime?>.between(
    param0: TypedExpression<LocalTime?>,
    param1: TypedExpression<LocalTime?>
): TypedExpression<Boolean>

between

fun <T : Comparable<*>?> TypedExpression<T>.between(
    param0: TypedExpression<T>,
    param1: T
): TypedExpression<Boolean>

between

fun <T : Comparable<*>?> TypedExpression<T>.between(param0: T, param1: T): TypedExpression<Boolean>

between

fun <T : Comparable<*>?> TypedExpression<T>.between(
    param0: T,
    param1: TypedExpression<T>
): TypedExpression<Boolean>

contains

infix fun <T : Any?> TypedExpression<List<T>?>.contains(constant: T): TypedExpression<Boolean>

An extension function of TypedExpression?> that performs the Contains operation on a constant using a list.

Parameters
`constant: T`	The constant expression.

Returns
`TypedExpression<Boolean>`	A `ListContains` instance.

contains

infix fun <T : Any?> TypedExpression<List<T>?>.contains(element: TypedExpression<T>): TypedExpression<Boolean>

An extension function of TypedExpression?> that performs the Contains operation on an expression using a list.

Returns
`TypedExpression<Boolean>`	A `ListContains` instance.

div

operator fun TypedExpression<UByte?>.div(param0: TypedExpression<UByte?>): TypedExpression<UByte>

div

operator fun TypedExpression<UInt?>.div(param0: TypedExpression<UInt?>): TypedExpression<UInt>

div

operator fun TypedExpression<ULong?>.div(param0: TypedExpression<ULong?>): TypedExpression<ULong>

div

operator fun TypedExpression<UShort?>.div(param0: TypedExpression<UShort?>): TypedExpression<UShort>

div

operator fun <T : Number?> TypedExpression<T>.div(param0: TypedExpression<T>): TypedExpression<T>

div

operator fun TypedExpression<UByte?>.div(param0: UByte): TypedExpression<UByte>

div

operator fun TypedExpression<UInt?>.div(param0: UInt): TypedExpression<UInt>

div

operator fun TypedExpression<ULong?>.div(param0: ULong): TypedExpression<ULong>

div

operator fun TypedExpression<UShort?>.div(param0: UShort): TypedExpression<UShort>

div

operator fun <T : Number?> TypedExpression<T>.div(param0: T): TypedExpression<T>

equals

infix fun <T : Any?> TypedExpression<T>.equals(param0: TypedExpression<T>): TypedExpression<Boolean>

equals

infix fun <T : Any?> TypedExpression<T>.equals(param0: T): TypedExpression<Boolean>

filter

infix fun <T : Any?> TypedExpression<List<T>?>.filter(
    body: (TypedExpression<T>) -> TypedExpression<Boolean>
): TypedExpression<List<T>?>

An extension function of TypedExpression?> that performs Filter operation on list using the lambda condition.

get

operator fun <T : Any?> TypedExpression<List<T>?>.get(constant: Int): TypedExpression<T?>

An extension function of TypedExpression?> that performs the Get operation on a constant using a list.

Parameters
`constant: Int`	The constant expression.

Returns
`TypedExpression<T?>`	A `ListGet` instance.

get

operator fun <T : Any?> TypedExpression<List<T>?>.get(constant: UInt): TypedExpression<T?>

An extension function of TypedExpression?> that performs the Get operation on a constant using a list.

Parameters
`constant: UInt`	The constant expression.

Returns
`TypedExpression<T?>`	A `ListGet` instance.

get

operator fun <T : Any?> TypedExpression<List<T>?>.get(index: TypedExpression<Int?>): TypedExpression<T?>

An extension function of TypedExpression?> that performs the Get operation on an expression using a list.

Returns
`TypedExpression<T?>`	A `ListGet` instance.

get

operator fun <T : Any?> TypedExpression<List<T>?>.get(index: TypedExpression<UInt?>): TypedExpression<T?>

An extension function of TypedExpression?> that performs the Get operation on an expression using a list.

Returns
`TypedExpression<T?>`	A `ListGet` instance.

greaterThan

infix fun TypedExpression<Duration?>.greaterThan(param0: Duration): TypedExpression<Boolean>

greaterThan

infix fun <T : Comparable<*>?> TypedExpression<T>.greaterThan(
    param0: TypedExpression<T>
): TypedExpression<Boolean>

greaterThan

infix fun TypedExpression<Duration?>.greaterThan(
    param0: TypedExpression<Duration?>
): TypedExpression<Boolean>

greaterThan

infix fun <T : Comparable<*>?> TypedExpression<T>.greaterThan(param0: T): TypedExpression<Boolean>

greaterThanOrEquals

infix fun TypedExpression<Duration?>.greaterThanOrEquals(param0: Duration): TypedExpression<Boolean>

greaterThanOrEquals

infix fun <T : Comparable<*>?> TypedExpression<T>.greaterThanOrEquals(
    param0: TypedExpression<T>
): TypedExpression<Boolean>

greaterThanOrEquals

infix fun TypedExpression<Duration?>.greaterThanOrEquals(
    param0: TypedExpression<Duration?>
): TypedExpression<Boolean>

greaterThanOrEquals

infix fun <T : Comparable<*>?> TypedExpression<T>.greaterThanOrEquals(param0: T): TypedExpression<Boolean>

inList

infix fun <T : Any?> TypedExpression<T>.inList(
    listExpression: TypedExpression<List<T>?>
): TypedExpression<Boolean>

An extension function of Expression that performs In operation on an expression list

inList

infix fun <T : Any?> TypedExpression<T>.inList(list: List<T>): TypedExpression<Boolean>

An extension function of Constant that performs In operation on a constant list

lessThan

infix fun TypedExpression<Duration?>.lessThan(param0: Duration): TypedExpression<Boolean>

lessThan

infix fun <T : Comparable<*>?> TypedExpression<T>.lessThan(
    param0: TypedExpression<T>
): TypedExpression<Boolean>

lessThan

infix fun TypedExpression<Duration?>.lessThan(param0: TypedExpression<Duration?>): TypedExpression<Boolean>

lessThan

infix fun <T : Comparable<*>?> TypedExpression<T>.lessThan(param0: T): TypedExpression<Boolean>

lessThanOrEquals

infix fun TypedExpression<Duration?>.lessThanOrEquals(param0: Duration): TypedExpression<Boolean>

lessThanOrEquals

infix fun <T : Comparable<*>?> TypedExpression<T>.lessThanOrEquals(
    param0: TypedExpression<T>
): TypedExpression<Boolean>

lessThanOrEquals

infix fun TypedExpression<Duration?>.lessThanOrEquals(
    param0: TypedExpression<Duration?>
): TypedExpression<Boolean>

lessThanOrEquals

infix fun <T : Comparable<*>?> TypedExpression<T>.lessThanOrEquals(param0: T): TypedExpression<Boolean>

map

infix fun <T : Any?, U : Any?> TypedExpression<List<T>?>.map(
    body: (TypedExpression<T>) -> TypedExpression<U>
): TypedExpression<List<U>?>

An extension function of TypedExpression?> that performs Map operation on list using the lambda condition.

minus

operator fun TypedExpression<LocalTime?>.minus(param0: Duration): TypedExpression<LocalTime>

minus

operator fun TypedExpression<Duration?>.minus(param0: Duration): TypedExpression<Duration>

minus

operator fun TypedExpression<UByte?>.minus(param0: TypedExpression<UByte?>): TypedExpression<UByte>

minus

operator fun TypedExpression<UInt?>.minus(param0: TypedExpression<UInt?>): TypedExpression<UInt>

minus

operator fun TypedExpression<ULong?>.minus(param0: TypedExpression<ULong?>): TypedExpression<ULong>

minus

operator fun TypedExpression<UShort?>.minus(param0: TypedExpression<UShort?>): TypedExpression<UShort>

minus

operator fun <T : Number?> TypedExpression<T>.minus(param0: TypedExpression<T>): TypedExpression<T>

minus

operator fun TypedExpression<LocalTime?>.minus(param0: TypedExpression<Duration?>): TypedExpression<LocalTime>

minus

operator fun TypedExpression<Duration?>.minus(param0: TypedExpression<Duration?>): TypedExpression<Duration>

minus

operator fun TypedExpression<UByte?>.minus(param0: UByte): TypedExpression<UByte>

minus

operator fun TypedExpression<UInt?>.minus(param0: UInt): TypedExpression<UInt>

minus

operator fun TypedExpression<ULong?>.minus(param0: ULong): TypedExpression<ULong>

minus

operator fun TypedExpression<UShort?>.minus(param0: UShort): TypedExpression<UShort>

minus

operator fun <T : Number?> TypedExpression<T>.minus(param0: T): TypedExpression<T>

none

infix fun <T : Any?> TypedExpression<List<T>?>.none(
    body: (TypedExpression<T>) -> TypedExpression<Boolean>
): TypedExpression<Boolean>

An extension function of TypedExpression?> that performs None match operation on list using the lambda condition.

notEquals

infix fun <T : Any?> TypedExpression<T>.notEquals(param0: TypedExpression<T>): TypedExpression<Boolean>

notEquals

infix fun <T : Any?> TypedExpression<T>.notEquals(param0: T): TypedExpression<Boolean>

or

infix fun TypedExpression<Boolean>.or(other: TypedExpression<Boolean>): TypedExpression<Boolean>

Allows the use of the Or operator in an infix manner.

plus

operator fun TypedExpression<LocalTime?>.plus(param0: Duration): TypedExpression<LocalTime>

plus

operator fun TypedExpression<Duration?>.plus(param0: Duration): TypedExpression<Duration>

plus

operator fun TypedExpression<String?>.plus(param0: String): TypedExpression<String>

plus

operator fun TypedExpression<UByte?>.plus(param0: TypedExpression<UByte?>): TypedExpression<UByte>

plus

operator fun TypedExpression<UInt?>.plus(param0: TypedExpression<UInt?>): TypedExpression<UInt>

plus

operator fun TypedExpression<ULong?>.plus(param0: TypedExpression<ULong?>): TypedExpression<ULong>

plus

operator fun TypedExpression<UShort?>.plus(param0: TypedExpression<UShort?>): TypedExpression<UShort>

plus

operator fun <T : Number?> TypedExpression<T>.plus(param0: TypedExpression<T>): TypedExpression<T>

plus

operator fun TypedExpression<String?>.plus(param0: TypedExpression<String?>): TypedExpression<String>

plus

operator fun TypedExpression<LocalTime?>.plus(param0: TypedExpression<Duration?>): TypedExpression<LocalTime>

plus

operator fun TypedExpression<Duration?>.plus(param0: TypedExpression<Duration?>): TypedExpression<Duration>

plus

operator fun TypedExpression<UByte?>.plus(param0: UByte): TypedExpression<UByte>

plus

operator fun TypedExpression<UInt?>.plus(param0: UInt): TypedExpression<UInt>

plus

operator fun TypedExpression<ULong?>.plus(param0: ULong): TypedExpression<ULong>

plus

operator fun TypedExpression<UShort?>.plus(param0: UShort): TypedExpression<UShort>

plus

operator fun <T : Number?> TypedExpression<T>.plus(param0: T): TypedExpression<T>

times

operator fun TypedExpression<UByte?>.times(param0: TypedExpression<UByte?>): TypedExpression<UByte>

times

operator fun TypedExpression<UInt?>.times(param0: TypedExpression<UInt?>): TypedExpression<UInt>

times

operator fun TypedExpression<ULong?>.times(param0: TypedExpression<ULong?>): TypedExpression<ULong>

times

operator fun TypedExpression<UShort?>.times(param0: TypedExpression<UShort?>): TypedExpression<UShort>

times

operator fun <T : Number?> TypedExpression<T>.times(param0: TypedExpression<T>): TypedExpression<T>

times

operator fun TypedExpression<UByte?>.times(param0: UByte): TypedExpression<UByte>

times

operator fun TypedExpression<UInt?>.times(param0: UInt): TypedExpression<UInt>

times

operator fun TypedExpression<ULong?>.times(param0: ULong): TypedExpression<ULong>

times

operator fun TypedExpression<UShort?>.times(param0: UShort): TypedExpression<UShort>

times

operator fun <T : Number?> TypedExpression<T>.times(param0: T): TypedExpression<T>

toByte

fun TypedExpression<Short?>.toByte(): TypedExpression<Byte?>

toByte

fun TypedExpression<Int?>.toByte(): TypedExpression<Byte?>

toByte

fun TypedExpression<Long?>.toByte(): TypedExpression<Byte?>

toDouble

fun TypedExpression<Float?>.toDouble(): TypedExpression<Double?>

toFloat

fun TypedExpression<Double?>.toFloat(): TypedExpression<Float?>

toInt

fun TypedExpression<Byte?>.toInt(): TypedExpression<Int?>

toInt

fun TypedExpression<Short?>.toInt(): TypedExpression<Int?>

toInt

fun TypedExpression<Long?>.toInt(): TypedExpression<Int?>

toLong

fun TypedExpression<Byte?>.toLong(): TypedExpression<Long?>

toLong

fun TypedExpression<Short?>.toLong(): TypedExpression<Long?>

toLong

fun TypedExpression<Int?>.toLong(): TypedExpression<Long?>

toShort

fun TypedExpression<Byte?>.toShort(): TypedExpression<Short?>

toShort

fun TypedExpression<Int?>.toShort(): TypedExpression<Short?>

toShort

fun TypedExpression<Long?>.toShort(): TypedExpression<Short?>

toUByte

fun TypedExpression<UShort?>.toUByte(): TypedExpression<UByte?>

toUByte

fun TypedExpression<UInt?>.toUByte(): TypedExpression<UByte?>

toUByte

fun TypedExpression<ULong?>.toUByte(): TypedExpression<UByte?>

toUInt

fun TypedExpression<UByte?>.toUInt(): TypedExpression<UInt?>

toUInt

fun TypedExpression<UShort?>.toUInt(): TypedExpression<UInt?>

toUInt

fun TypedExpression<ULong?>.toUInt(): TypedExpression<UInt?>

toULong

fun TypedExpression<UByte?>.toULong(): TypedExpression<ULong?>

toULong

fun TypedExpression<UShort?>.toULong(): TypedExpression<ULong?>

toULong

fun TypedExpression<UInt?>.toULong(): TypedExpression<ULong?>

toUShort

fun TypedExpression<UByte?>.toUShort(): TypedExpression<UShort?>

toUShort

fun TypedExpression<UInt?>.toUShort(): TypedExpression<UShort?>

toUShort

fun TypedExpression<ULong?>.toUShort(): TypedExpression<UShort?>

Extension properties

size

val TypedExpression<List<*>?>.size: TypedExpression<Int>

An extension property of TypedExpression?> that performs the Size operation on list.