Default package

Get desktop application:
View/edit binary Protocol Buffers messages

• rpc planAnytime (PlanRequest, stream PlanGenerationResult)

  unified_planning.proto:885

  An anytime plan request to the engine. The engine replies with a stream of N `Answer` messages where: - the first (N-1) message are of type `IntermediateReport` - the last message is of type `FinalReport`

• rpc planOneShot (PlanRequest, PlanGenerationResult)

  unified_planning.proto:889

  A oneshot plan request to the engine. The engine replies with athe PlanGenerationResult

• rpc validatePlan (ValidationRequest, ValidationResult)

  unified_planning.proto:893

  A validation request to the engine. The engine replies with the ValidationResult

  message ValidationRequest

  unified_planning.proto:754

  • optional Problem problem = 1

    Problem to be validated.

  • optional Plan plan = 2

    Plan to validate.

  message ValidationResult

  unified_planning.proto:839

  Message sent by the validator.

  • ValidationResult.ValidationResultStatus status = 1

  • map<string, string> metrics = 4

    A set of engine specific values that can be reported

  • repeated LogMessage log_messages = 2

    Optional. Information given by the engine to the user.

  • optional Engine engine = 3

    Synthetic description of the engine that generated this message.

• rpc compile (Problem, CompilerResult)

  unified_planning.proto:897

  A compiler request to the engine. The engine replies with the CompilerResult

  message CompilerResult

  unified_planning.proto:863

  Message sent by the grounder.

  • optional Problem problem = 1

    The problem generated by the Compiler

  • map<string, ActionInstance> map_back_plan = 2

    The map_back_plan field is a map from the ActionInstance of the compiled problem to the original ActionInstance.

  • map<string, string> metrics = 5

    A set of engine specific values that can be reported

  • repeated LogMessage log_messages = 3

    Optional. Information given by the engine to the user.

  • optional Engine engine = 4

    Synthetic description of the engine that generated this message.

Declares an abstract task together with its expected parameters. Example: goto(robot: Robot, destination: Location)

Used in: Hierarchy

• string name = 1

  Example: "goto"

• repeated Parameter parameters = 2

  Example: - robot: Robot - destination: Location

Unified action representation that represents any kind of actions.

Used in: Problem

• string name = 1

  Action name. E.g. "move"

• repeated Parameter parameters = 2

  Typed and named parameters of the action.

• optional Duration duration = 3

  If set, the action is durative. Otherwise it is instantaneous. features: DURATIVE_ACTIONS

• repeated Condition conditions = 4

  Conjunction of conditions that must hold for the action to be applicable.

• repeated Effect effects = 5

  Conjunction of effects as a result of applying this action.

Representation of an action instance that appears in a plan.

Used in: CompilerResult, Plan

• string id = 1

  Optional. A unique identifier of the action that might be used to refer to it (e.g. in HTN plans).

• string action_name = 2

  name of the action

• repeated Atom parameters = 3

  Parameters of the action instance, required to be constants.

• optional Real start_time = 4

  Start time of the action. The default 0 value is OK in the case of non-temporal planning feature: [DURATIVE_ACTIONS]

• optional Real end_time = 5

  End time of the action. The default 0 value is OK in the case of non-temporal planning feature: [DURATIVE_ACTIONS]

Activity in a scheduling problem.

Used in: SchedulingExtension

• string name = 1

  Name of the activity that must uniquely identify it.

• repeated Parameter parameters = 2

  Typed and named parameters of the activity.

• optional Duration duration = 3

  Duration of the activity

• repeated Condition conditions = 4

  Conjunction of conditions that must hold if the activity is present.

• repeated Effect effects = 5

  Conjunction of effects that this activity produces.

• repeated Expression constraints = 6

  Conjunction of static constraints that must hold if the activity is present.

An assignment of a value to a fluent, as it appears in the initial state definition.

Used in: Problem

• optional Expression fluent = 1

  State variable that is assigned the `value`. It should be an expression of the STATE_VARIABLE kind for which all parameters are of the CONSTANT kind.

• optional Expression value = 2

  An expression of the CONSTANT kind, denoting the value take by the state variable.

Used in: ActionInstance, Expression, MethodInstance, Schedule

• oneof content

  • string symbol = 1

  • int64 int = 2

  • Real real = 3

  • bool boolean = 4

Used in: Action, Activity, Method

• optional Expression cond = 1

• optional TimeInterval span = 2

  Optional. Must be set for durative actions where it specifies the temporal interval over which when the condition should hold. features: DURATIVE_ACTIONS

Used in: Action, Activity

• optional Interval controllable_in_bounds = 1

  / The duration of the action can be freely chosen within the indicated bounds

Representation of an effect that allows qualifying the effect expression, e.g., to make it a conditional effect.

Used in: Action, Activity

• optional EffectExpression effect = 1

  Required. The actual effect that should take place.

• optional Timing occurrence_time = 2

  Optional. If the effect is within a durative action, the following must be set and will specify when the effect takes place. features: DURATIVE_ACTIONS

An effect expression is of the form `FLUENT OP VALUE`. We explicitly restrict the different types of effects by setting the allowed operators.

Used in: Effect, TimedEffect

• EffectExpression.EffectKind kind = 1

• optional Expression fluent = 2

  Expression that must be of the STATE_VARIABLE kind.

• optional Expression value = 3

• optional Expression condition = 4

  Optional. If the effect is conditional, then the following field must be set. In this case, the `effect` will only be applied if the `condition`` holds. If the effect is unconditional, the effect is set to the constant 'true' value. features: CONDITIONAL_EFFECT

• repeated Expression forall = 5

  The variables that quantify this effect

Used in: EffectExpression

• ASSIGN = 0

  The `fluent` is set to the corresponding `value`

• INCREASE = 1

  The `fluent` is increased by the amount `value` features: INCREASE_EFFECTS

• DECREASE = 2

  The `fluent` is decreased by the amount `value` features: DECREASE_EFFECTS

Used in: CompilerResult, PlanGenerationResult, ValidationResult

• string name = 1

  Short name of the engine (planner, validator, ...)

As in s-expression, an Expression is either an atom or list representing the application of some parameters to a function/fluent.

Used in: Activity, Assignment, Condition, EffectExpression, Fluent, Goal, GoalWithWeight, Interval, Method, Metric, Problem, SchedulingExtension, Task, TaskNetwork, TimedGoalWithWeight

• optional Atom atom = 1

  If non-empty, the expression is a single atom. For instance `3`, `+`, `kitchen`, `at-robot`, ...

• repeated Expression list = 2

  If the `atom` field is empty, then the expression is a list of sub-expressions, typically representing the application of some arguments to a function or fluent. For instance `(+ 1 3)`, (at-robot l1)`, `(>= (battery_level) 20)`

• string type = 3

  Type of the expression. For instance "int", "location", ...

• ExpressionKind kind = 4

  Kind of the expression, specifying the content of the expression. This is intended to facilitate parsing of the expression.

The kind of an expression, which gives information related to its structure.

Used in: Expression

• UNKNOWN = 0

  Default value, should not be used. Drop it if we are sure to never need it.

• CONSTANT = 1

  Constant atom. For instance `3` or `kitchen` (where `kitchen` is an object defined in the problem)

• PARAMETER = 2

  Atom symbol representing a parameter from an outer scope. For instance `from` that would appear inside a `(move from to - location)` action.

• VARIABLE = 7

  Atom symbol representing a variable from an outer scope. This is typically used to represent the variables that are existentially or universally qualified in expressions.

• FLUENT_SYMBOL = 3

  Atom symbol representing a fluent of the problem. For instance `at-robot`.

• FUNCTION_SYMBOL = 4

  Atom representing a function. For instance `+`, `=`, `and`, ...

• STATE_VARIABLE = 5

  List. Application of some parameters to a fluent symbol. For instance `(at-robot l1)` or `(battery-charged)` The first element of the list must be a FLUENT_SYMBOL

• FUNCTION_APPLICATION = 6

  List. The expression is the application of some parameters to a function. For instance `(+ 1 3)`. The first element of the list must be a FUNCTION_SYMBOL

• CONTAINER_ID = 8

  Atom symbol. Unique identifier of a task or action in the current scope.

Features of the problem. Features are essential in that not supporting a feature `X` should allow disregarding any field tagged with `features: [X]`.

Used in: Problem

• ACTION_BASED = 0

  PROBLEM_CLASS

• HIERARCHICAL = 26

• SCHEDULING = 56

• SIMPLE_NUMERIC_PLANNING = 30

  PROBLEM_TYPE

• GENERAL_NUMERIC_PLANNING = 31

• CONTINUOUS_TIME = 1

  TIME

• DISCRETE_TIME = 2

• INTERMEDIATE_CONDITIONS_AND_EFFECTS = 3

• EXTERNAL_CONDITIONS_AND_EFFECTS = 39

• TIMED_EFFECTS = 4

• TIMED_GOALS = 5

• DURATION_INEQUALITIES = 6

• SELF_OVERLAPPING = 47

• STATIC_FLUENTS_IN_DURATIONS = 27

  EXPRESSION_DURATION

• FLUENTS_IN_DURATIONS = 28

• REAL_TYPE_DURATIONS = 62

• INT_TYPE_DURATIONS = 63

• CONTINUOUS_NUMBERS = 7

  NUMBERS

• DISCRETE_NUMBERS = 8

• BOUNDED_TYPES = 38

• NEGATIVE_CONDITIONS = 9

  CONDITIONS_KIND

• DISJUNCTIVE_CONDITIONS = 10

• EQUALITIES = 11

• EXISTENTIAL_CONDITIONS = 12

• UNIVERSAL_CONDITIONS = 13

• CONDITIONAL_EFFECTS = 14

  EFFECTS_KIND

• INCREASE_EFFECTS = 15

• DECREASE_EFFECTS = 16

• STATIC_FLUENTS_IN_BOOLEAN_ASSIGNMENTS = 41

• STATIC_FLUENTS_IN_NUMERIC_ASSIGNMENTS = 42

• STATIC_FLUENTS_IN_OBJECT_ASSIGNMENTS = 57

• FLUENTS_IN_BOOLEAN_ASSIGNMENTS = 43

• FLUENTS_IN_NUMERIC_ASSIGNMENTS = 44

• FLUENTS_IN_OBJECT_ASSIGNMENTS = 58

• FORALL_EFFECTS = 59

• FLAT_TYPING = 17

  TYPING

• HIERARCHICAL_TYPING = 18

• NUMERIC_FLUENTS = 19

  FLUENTS_TYPE

• OBJECT_FLUENTS = 20

• INT_FLUENTS = 60

• REAL_FLUENTS = 61

• BOOL_FLUENT_PARAMETERS = 50

  PARAMETERS

• BOUNDED_INT_FLUENT_PARAMETERS = 51

• BOOL_ACTION_PARAMETERS = 52

• BOUNDED_INT_ACTION_PARAMETERS = 53

• UNBOUNDED_INT_ACTION_PARAMETERS = 54

• REAL_ACTION_PARAMETERS = 55

• ACTIONS_COST = 21

  QUALITY_METRICS

• FINAL_VALUE = 22

• MAKESPAN = 23

• PLAN_LENGTH = 24

• OVERSUBSCRIPTION = 29

• TEMPORAL_OVERSUBSCRIPTION = 40

• STATIC_FLUENTS_IN_ACTIONS_COST = 45

  ACTION_COST_KIND

• FLUENTS_IN_ACTIONS_COST = 46

• REAL_NUMBERS_IN_ACTIONS_COST = 64

• INT_NUMBERS_IN_ACTIONS_COST = 65

• REAL_NUMBERS_IN_OVERSUBSCRIPTION = 66

  OVERSUBSCRIPTION_KIND

• INT_NUMBERS_IN_OVERSUBSCRIPTION = 67

• SIMULATED_EFFECTS = 25

  SIMULATED_ENTITIES

• TRAJECTORY_CONSTRAINTS = 48

  CONSTRAINTS_KIND

• STATE_INVARIANTS = 49

• METHOD_PRECONDITIONS = 32

  HIERARCHICAL

• TASK_NETWORK_CONSTRAINTS = 33

• INITIAL_TASK_NETWORK_VARIABLES = 34

• TASK_ORDER_TOTAL = 35

• TASK_ORDER_PARTIAL = 36

• TASK_ORDER_TEMPORAL = 37

• UNDEFINED_INITIAL_NUMERIC = 68

  INITIAL_STATE

• UNDEFINED_INITIAL_SYMBOLIC = 69

A state-dependent variable.

Used in: Problem

• string name = 1

• string value_type = 2

  Return type of the fluent.

• repeated Parameter parameters = 3

  Typed and named parameters of the fluent.

• optional Expression default_value = 4

  If non-empty, then any state variable using this fluent that is not explicitly given a value in the initial state will be assumed to have this default value. This allows mimicking the closed world assumption by setting a "false" default value to predicates.

A Goal is currently an expression that must hold either: - in the final state, - over a specific temporal interval (under the `timed_goals` features)

Used in: Problem

• optional Expression goal = 1

  Goal expression that must hold in the final state.

• optional TimeInterval timing = 2

  Optional. If specified the goal should hold over the specified temporal interval (instead of on the final state). features: TIMED_GOALS

Represents a goal associated with a weight, used to define oversubscription planning.

Used in: Metric

• optional Expression goal = 1

  Goal expression

• optional Real weight = 2

  The weight

Represents the hierarchical part of a problem. features: hierarchical

Used in: Problem

• repeated AbstractTaskDeclaration abstract_tasks = 1

• repeated Method methods = 2

• optional TaskNetwork initial_task_network = 3

An interval `[lower, upper]` where `lower` and `upper` are arbitrary expressions. The `is_left_open` and `is_right_open` fields indicate whether the interval is opened on left and right side respectively.

Used in: Duration

• bool is_left_open = 1

• optional Expression lower = 2

• bool is_right_open = 3

• optional Expression upper = 4

A freely formatted logging message. Each message is annotated with its criticality level from the minimal (DEBUG) to the maximal (ERROR). Criticality level is expected to be used by an end user to decide the level of verbosity.

Used in: CompilerResult, PlanGenerationResult, ValidationResult

• LogMessage.LogLevel level = 1

• string message = 2

Used in: LogMessage

• DEBUG = 0

• INFO = 1

• WARNING = 2

• ERROR = 3

A method describes one possible way of achieving a task. Example: A method that make a "move" action and recursively calls itself until reaching the destination.

Used in: Hierarchy

• string name = 1

  A name that uniquely identify the method. This is mostly used for user facing output or plan validation. Example: "m-recursive-goto"

• repeated Parameter parameters = 2

  Example: [robot: Robot, source: Location, intermediate: Location, destination: Location]

• optional Task achieved_task = 3

  The task that is achieved by the method. A subset of the parameters of the method will typically be used to define the task that is achieved. Example: goto(robot, destination)

• repeated Task subtasks = 4

  A set of subtasks that should be achieved to carry out the method. Note that the order of subtasks is irrelevant and that any ordering constraint should be specified in the `constraints` field. Example: - t1: (move robot source intermediate) - t2: goto(robot destination)

• repeated Expression constraints = 5

  Constraints enable the definition of ordering constraints as well as constraints on the allowed instantiation of the method's parameters. Example: - end(t1) < start(t2) - source != intermediate

• repeated Condition conditions = 6

  Conjunction of conditions that must hold for the method to be applicable. As for the conditions of actions, these can be temporally qualified to refer to intermediate timepoints. In addition to the start/end of the method, the temporal qualification might refer to the start/end of one of the subtasks using its identifier. Example: - [start] loc(robot) == source - [end(t1)] loc(robot) == intermediate - [end] loc(robot) == destination

Used in: PlanHierarchy

• string id = 1

  A unique identifier of the method that is used to refer to it in the hierarchy.

• string method_name = 2

  name of the method

• repeated Atom parameters = 3

  Parameters of the method instance, required to be constants.

• map<string, string> subtasks = 6

  A mapping of the IDs of the method's subtasks into the IDs of the action/methods that refine them.

Used in: Problem

• Metric.MetricKind kind = 1

• optional Expression expression = 2

  Expression to minimize/maximize in the final state. Empty, if the `kind` is not {MIN/MAX}IMIZE_EXPRESSION_ON_FINAL_STATE

• map<string, Expression> action_costs = 3

  If `kind == MINIMIZE_ACTION_COSTS``, then each action is associated to a cost expression. TODO: Document what is allowed in the expression. See issue #134 In particular, for this metric to be useful in many practical problems, the cost expression should allow referring to the action parameters (and possibly the current state at the action start/end). This is very awkward to do in this setting where the expression is detached from its scope.

• optional Expression default_action_cost = 4

• repeated GoalWithWeight goals = 5

  List of goals used to define the oversubscription planning problem. Empty, if the `kind` is not OVERSUBSCRIPTION

• repeated TimedGoalWithWeight timed_goals = 6

  List of timed goals used to define the temporal oversubscription planning problem. Empty, if the `kind` is not TEMPORAL_OVERSUBSCRIPTION

Used in: Metric

• MINIMIZE_ACTION_COSTS = 0

  Minimize the action costs expressed in the `action_costs` field

• MINIMIZE_SEQUENTIAL_PLAN_LENGTH = 1

  Minimize the length of the resulting sequential plan

• MINIMIZE_MAKESPAN = 2

  Minimize the makespan in case of temporal planning features: durative_actions

• MINIMIZE_EXPRESSION_ON_FINAL_STATE = 3

  Minimize the value of the expression defined in the `expression` field

• MAXIMIZE_EXPRESSION_ON_FINAL_STATE = 4

  Maximize the value of the expression defined in the `expression` field

• OVERSUBSCRIPTION = 5

  Maximize the weighted number of goals reached

• TEMPORAL_OVERSUBSCRIPTION = 6

  Maximize the weighted number of timed goals reached

Declares an object with the given name and type.

Used in: Problem

• string name = 1

  Name of the object.

• string type = 2

  Type of the object. The type must have been previously declared in the problem definition.

Parameter of a fluent or of an action

Used in: AbstractTaskDeclaration, Action, Activity, Fluent, Method, SchedulingExtension, TaskNetwork

• string name = 1

  Name of the parameter.

• string type = 2

  Type of the parameter.

Used in: PlanGenerationResult, ValidationRequest

• repeated ActionInstance actions = 1

  An ordered sequence of actions that appear in the plan. The order of the actions in the list must be compatible with the partial order of the start times. In case of non-temporal planning, this allows having all start time at 0 and only rely on the order in this sequence. features: ACTION_BASED

• optional PlanHierarchy hierarchy = 2

  When the plan is hierarchical, this object provides the decomposition of hte root tasks into the actions of the plan feature: HIERARCHY

• optional Schedule schedule = 3

  Solution representation of a scheduling problem. feature: SCHEDULING

Message sent by engine. Contains the engine exit status as well as the best plan found if any.

Used as response type in: UnifiedPlanning.planAnytime, UnifiedPlanning.planOneShot

• PlanGenerationResult.Status status = 1

• optional Plan plan = 2

  Optional. Best plan found if any.

• map<string, string> metrics = 3

  A set of engine specific values that can be reported, for instance - "grounding-time": "10ms" - "expanded-states": "1290"

• repeated LogMessage log_messages = 4

  Optional log messages about the engine's activity. Note that it should not be expected that logging messages are visible to the end user. If used in conjunction with INTERNAL_ERROR or UNSUPPORTED_PROBLEM, it would be expected to have at least one log message at the ERROR level.

• optional Engine engine = 5

  Synthetic description of the engine that generated this message.

==== Engine stopped normally ======

Used in: PlanGenerationResult

• SOLVED_SATISFICING = 0

  Valid plan found The `plan` field must be set.

• SOLVED_OPTIMALLY = 1

  Plan found with optimality guarantee The `plan` field must be set and contains an optimal solution.

• UNSOLVABLE_PROVEN = 2

  No plan exists

• UNSOLVABLE_INCOMPLETELY = 3

  The engine was not able to find a solution but does not give any guarantee that none exist (i.e. the engine might not be complete)

• TIMEOUT = 13

  The engine ran out of time

• MEMOUT = 14

  The engine ran out of memory

• INTERNAL_ERROR = 15

  The engine faced an internal error.

• UNSUPPORTED_PROBLEM = 16

  The problem submitted is not supported by the engine.

• INTERMEDIATE = 17

  ====== Intermediate answer ====== This Answer is an Intermediate Answer and not a Final one

Used in: Plan

• map<string, string> root_tasks = 1

  A mapping of the root task IDs into the IDs of the actions and methods that refine them.

• repeated MethodInstance methods = 2

  Instances of all methods used in the plan.

Used as request type in: UnifiedPlanning.planAnytime, UnifiedPlanning.planOneShot

• optional Problem problem = 1

  Problem that should be solved.

• PlanRequest.Mode resolution_mode = 2

• double timeout = 3

  Max allowed runtime time in seconds.

• map<string, string> engine_options = 4

  Engine specific options to be passed to the engine

Used in: PlanRequest

• SATISFIABLE = 0

• SOLVED_OPTIMALLY = 1

Used as request type in: UnifiedPlanning.compile

Used as field type in: CompilerResult, PlanRequest, ValidationRequest

• string domain_name = 1

• string problem_name = 2

• repeated TypeDeclaration types = 3

• repeated Fluent fluents = 4

• repeated ObjectDeclaration objects = 5

• repeated Action actions = 6

  List of actions in the domain. features: ACTION_BASED

• repeated Assignment initial_state = 7

  Explicit assignments to state variables in the initial state. State variables not assigned there and will take the default value of their fluent, if any.

• repeated TimedEffect timed_effects = 8

  Facts and effects that are expected to occur strictly later than the initial state. features: TIMED_EFFECTS

• repeated Goal goals = 9

  Goals of the planning problem.

• repeated Feature features = 10

  all features of the problem

• repeated Metric metrics = 11

  The plan quality metrics

• optional Hierarchy hierarchy = 12

  If the problem is hierarchical, defines the tasks and methods as well as the initial task network. features: HIERARCHICAL

• optional SchedulingExtension scheduling_extension = 17

  Scheduling-specific extension of the problem. features: SCHEDULING

• repeated Expression trajectory_constraints = 13

  Trajectory constraints of the planning problem.

• bool discrete_time = 14

  Flag defining if the time is discrete

• bool self_overlapping = 15

  Flag defining if the self_overlapping is allowed

• optional Real epsilon = 16

  Optional. epsilon required by the problem

Representation of a constant real number, as the fraction `(numerator / denominator)`. A real should be in its canonical form (with smallest possible denominator). Notably, if this number is an integer, then it is guaranteed that `denominator == 1`.

Used in: ActionInstance, Atom, GoalWithWeight, Problem, TimedGoalWithWeight, Timing

• int64 numerator = 1

• int64 denominator = 2

Used in: Plan

• repeated string activities = 1

  Name of the activities that appear in the solution

• map<string, Atom> variable_assignments = 2

  Assignment of all variables and activity parameters and timepoints that appear in the solution.

Extension of `Problem` for scheduling

Used in: Problem

• repeated Activity activities = 1

  All potential activities of the scheduling problem.

• repeated Parameter variables = 2

  All variables in the base problem

• repeated Expression constraints = 5

  All constraints in the base problem.

Representation of an abstract or primitive task that should be achieved, required either in the initial task network or as a subtask of a method. Example: task of sending a `robot` to the KITCHEN - t1: goto(robot, KITCHEN)

Used in: Method, TaskNetwork

• string id = 1

  Identifier of the task, required to be unique in the method/task-network where the task appears. The `id` is notably used to refer to the start/end of the task. Example: t1

• string task_name = 2

  Name of the task that should be achieved. It might either - an abstract task if the name is the one of a task declared in the problem - a primitive task if the name is the one of an action declared in the problem Example: - "goto" (abstract task) - "move" (action / primitive task)

• repeated Expression parameters = 3

  Example: (for a "goto" task) - robot (a parameter from an outer scope) - KITCHEN (a constant symbol in the problem)

A task network defines a set of subtasks and associated constraints. It is intended to be used to define the initial task network of the hierarchical problem. Example: an arbitrary robot should go to the KITCHEN before time 100

Used in: Hierarchy

• repeated Parameter variables = 1

  robot: Location

• repeated Task subtasks = 2

  t1: goto(robot, KITCHEN)

• repeated Expression constraints = 3

  end(t1) <= 100

A contiguous slice of time represented as an interval `[lower, upper]` where `lower` and `upper` are time references. The `is_left_open` and `is_right_open` fields indicate whether the interval is opened on left and right side respectively.

Used in: Condition, Goal, TimedGoalWithWeight

• bool is_left_open = 1

• optional Timing lower = 2

• bool is_right_open = 3

• optional Timing upper = 4

Represents an effect that will occur sometime beyond the initial state. (similar to timed initial literals)

Used in: Problem

• optional EffectExpression effect = 1

  Required. An effect expression that will take place sometime in the future (i.e. not at the intial state) as specified by the temporal qualifiation.

• optional Timing occurrence_time = 2

  Required. Temporal qualification denoting when the timed fact will occur.

Represents a timed goal associated with a weight, used to define temporal oversubscription planning.

Used in: Metric

• optional Expression goal = 1

  Goal expression

• optional TimeInterval timing = 2

  The time interval

• optional Real weight = 3

  The weight

Symbolic reference to an absolute time. It might represent: - the time of the initial/final state, or - the start/end of the containing action, or - the start/end of one of the subtask in the context of a method or of a task network.

Used in: Timing

• Timepoint.TimepointKind kind = 1

• string container_id = 2

  If non-empty, identifies the container of which we are extracting the start/end timepoint. In the context of a task-network or of a method, this could be the `id` of one of the subtasks. feature: hierarchies

Used in: Timepoint

• GLOBAL_START = 0

  Global start of the planning problem. This is context independent and represents the time at which the initial state holds.

• GLOBAL_END = 1

  Global end of the planning problem. This is context independent and represents the time at which the final state holds.

• START = 2

  Start of the container (typically the action or method) in which this symbol occurs

• END = 3

  End of the container (typically the action or method) in which this symbol occurs

Represents a time (`timepoint` + `delay`), that is a time defined relatively to a particular `timepoint`. Note that an absolute time can be defined by setting the `delay` relative to the `GLOBAL_START`` which is the reference time.

Used in: Effect, TimeInterval, TimedEffect

• optional Timepoint timepoint = 1

• optional Real delay = 2

Declares the existence of a symbolic type.

Used in: Problem

• string type_name = 1

  Name of the type that is declared.

• string parent_type = 2

  Optional. If the string is non-empty, this is the parent type of `type_name`. If set, the parent type must have been previously declared (i.e. should appear earlier in the problem's type declarations. feature: HIERARCHICAL_TYPING

Used in: ValidationResult

• VALID = 0

  The Plan is valid for the Problem.

• INVALID = 1

  The Plan is not valid for the Problem.

• UNKNOWN = 2

  The engine can't determine if the plan is VALID or INVALID for the Problem.