@persei/perseed-api 5.0.19 → 5.0.21

package/dist/ecosystem-action-system.cjs

@@ -0,0 +1,586 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const typebox = require("typebox");
+const ecosystemParamsSchema = typebox.Type.Object(
+  {
+    ecosystemName: typebox.Type.String({ maxLength: 255, description: "Ecosystem name code" })
+  },
+  { title: "EcosystemParams", description: "Params with ecosystem name" }
+);
+const ecosystemProjectParamsSchema = typebox.Type.Intersect(
+  [
+    ecosystemParamsSchema,
+    typebox.Type.Object({
+      projectName: typebox.Type.String({ maxLength: 255, description: "Project name code" })
+    })
+  ],
+  { title: "EcosystemProjectParams", description: "Params with ecosystem name and project name" }
+);
+const ConditionsFormat = {
+  JSON_LOGIC: "jsonLogic",
+  CUSTOM: "custom"
+};
+const conditionsFormatSchema = typebox.Type.Enum(Object.values(ConditionsFormat), {
+  title: "ConditionsFormat",
+  description: "Format of the conditions evaluated by the conditions matcher"
+});
+const TriggerSource = {
+  MODEL: "model",
+  DESIGNER: "designer",
+  DISPLAYER: "displayer"
+};
+const triggerSourceSchema = typebox.Type.Enum(Object.values(TriggerSource), {
+  title: "TriggerSource",
+  description: "Source of the event that fires a trigger"
+});
+const TriggerOperation = {
+  CREATE: "create",
+  UPDATE: "update",
+  DELETE: "delete"
+};
+const triggerOperationSchema = typebox.Type.Enum(Object.values(TriggerOperation), {
+  title: "TriggerOperation",
+  description: "Operation on the target that fires the trigger"
+});
+const ActionType = {
+  API_ACTION: "ApiAction"
+};
+const actionTypeSchema = typebox.Type.Enum(Object.values(ActionType), {
+  title: "ActionType",
+  description: "Executable mechanism of an action"
+});
+const actionConfigBaseSchema = typebox.Type.Object(
+  {
+    id: typebox.Type.String({
+      description: 'Identifier of the concrete action within its type (e.g. the ApiAction value for type "ApiAction"). Any identifier for future types.'
+    }),
+    location: typebox.Type.Optional(
+      typebox.Type.String({
+        description: 'Where the effective config is resolved from. Generic string in the base; refined per type in the future (e.g. "inline" | "file").'
+      })
+    ),
+    overridable: typebox.Type.Optional(
+      typebox.Type.Array(typebox.Type.String(), {
+        description: "Allow-list of config keys a payload may override on top of `default`. Mandatory for override-types; absent for non-override types such as ApiAction."
+      })
+    ),
+    default: typebox.Type.Optional(
+      typebox.Type.Record(typebox.Type.String(), typebox.Type.Unknown(), {
+        description: "Base config an override-type merges its `payload` over (only overridable keys are applied)."
+      })
+    )
+  },
+  { title: "ActionConfigBase", description: "Base fields shared by every action config" }
+);
+const apiActionConfigSchema = typebox.Type.Intersect(
+  [
+    actionConfigBaseSchema,
+    typebox.Type.Object({
+      payload: typebox.Type.Record(typebox.Type.String(), typebox.Type.Unknown(), {
+        description: "Data mapping needed to run the ApiAction"
+      })
+    })
+  ],
+  { title: "ApiActionConfig", description: 'Config for actions of type "ApiAction"' }
+);
+const actionConfigSchema = typebox.Type.Union([apiActionConfigSchema], {
+  title: "ActionConfig",
+  description: "Union of action configs, selected by actions.type"
+});
+const ACTION_CONFIG_SCHEMAS = {
+  [ActionType.API_ACTION]: apiActionConfigSchema
+};
+const actionContextBaseSchema = typebox.Type.Object(
+  {
+    current: typebox.Type.Record(typebox.Type.String(), typebox.Type.Unknown(), {
+      description: "Current state of the entity that fired the event"
+    }),
+    old: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Record(typebox.Type.String(), typebox.Type.Unknown()), typebox.Type.Null()], {
+        description: "Previous state of the entity, when applicable (e.g. update/delete). Null otherwise"
+      })
+    ),
+    requestContextData: typebox.Type.Optional(
+      typebox.Type.Unknown({ description: "Snapshot of the request context (user, ecosystem, project…) when available" })
+    ),
+    // Declared even though `additionalProperties: true` would already let it through: what a
+    // condition may be written against is part of the contract, and a field only the engine knows
+    // about is one no admin can discover.
+    requester: typebox.Type.Optional(
+      typebox.Type.Unknown({
+        description: "Who is making the request — role, administrator flags, privileges and clinics of their profiling in the project. Absent when the request carries no user (an internal call, a job)"
+      })
+    ),
+    projectId: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Number(), typebox.Type.Null()], {
+        description: "Project the event belongs to. Null for ecosystem-wide events"
+      })
+    )
+  },
+  {
+    title: "ActionContextBase",
+    description: "Base fields of the context assembled for every action execution",
+    additionalProperties: true
+  }
+);
+const apiActionContextSchema = actionContextBaseSchema;
+const ACTION_CONTEXT_SCHEMAS = {
+  [ActionType.API_ACTION]: apiActionContextSchema
+};
+const triggerRelationsSchema = typebox.Type.Object(
+  {
+    join: typebox.Type.Optional(
+      typebox.Type.Array(
+        // A relation name, not free text: it is interpolated into the eager-loading graph
+        // expression. Objection resolves it against the relations declared on the model (never
+        // SQL), so an unknown name throws rather than leaking data — but validating the shape
+        // here turns that runtime failure into a 400 at the edge, which is cheaper to diagnose.
+        typebox.Type.String({ pattern: "^[A-Za-z_][A-Za-z0-9_]*$" }),
+        { description: 'Relation names to eager-load onto `current` (e.g. ["patient"])' }
+      )
+    )
+  },
+  { title: "TriggerRelations", additionalProperties: false }
+);
+const actionSchema = typebox.Type.Object(
+  {
+    id: typebox.Type.Number({ description: "Unique identifier of the action" }),
+    project_id: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Number(), typebox.Type.Null()], {
+        description: "Project this action belongs to. Null when it is ecosystem-wide"
+      })
+    ),
+    name: typebox.Type.String({ maxLength: 255, description: "Human-readable identifier of the action" }),
+    type: actionTypeSchema,
+    config: actionConfigSchema,
+    retention_days: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Number(), typebox.Type.Null()], {
+        description: "Retention in days for the process_log entries of this action (issue #175). Null = inherit (use the firing trigger retention; never if the trigger is null/0); 0 = disabled (never expires, regardless of the trigger); N (>0) = enabled (expires N days after write)."
+      })
+    ),
+    // Mirrors `dashboard_widget.library`. False by default, so an action created
+    // inline from a trigger screen is single-use unless it is said otherwise.
+    library: typebox.Type.Optional(
+      typebox.Type.Boolean({
+        description: "Whether the action belongs to the reusable catalog. False (the default) marks it single-use: it is deleted once no trigger links it any more, including before it is ever linked — a standalone action created through POST /action and left unlinked is swept as soon as any trigger of the project writes its links. Set it to true to create one that survives on its own"
+      })
+    )
+  },
+  { title: "Action", description: "Reusable executable action (ecosystem level)" }
+);
+const createActionSchema = typebox.Type.Omit(actionSchema, ["id", "project_id"], {
+  title: "CreateAction",
+  description: "Payload used to create an action",
+  additionalProperties: false
+});
+const updateActionSchema = typebox.Type.Partial(createActionSchema, {
+  title: "UpdateAction",
+  description: "Payload used to update an action",
+  additionalProperties: false
+});
+const triggerActionInputSchema = typebox.Type.Union(
+  [
+    typebox.Type.Number({ description: "Identifier of an existing action to link, left untouched" }),
+    typebox.Type.Object(
+      { ...createActionSchema.properties },
+      {
+        title: "TriggerActionCreate",
+        description: "Action created and linked in the same request",
+        additionalProperties: false
+      }
+    ),
+    typebox.Type.Object(
+      { id: typebox.Type.Number(), ...updateActionSchema.properties },
+      {
+        title: "TriggerActionUpdate",
+        description: "Existing action updated and linked in the same request",
+        additionalProperties: false
+      }
+    )
+  ],
+  { title: "TriggerActionInput", description: "An action a trigger runs: linked, created, or updated in place" }
+);
+const triggerActionsInputSchema = typebox.Type.Array(triggerActionInputSchema, {
+  description: "Full ordered set of actions the trigger runs; the array position is the execution order. An empty array leaves the trigger with none"
+});
+const automaticTriggerSchema = typebox.Type.Object(
+  {
+    id: typebox.Type.Number({ description: "Unique identifier of the automatic trigger" }),
+    project_id: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Number(), typebox.Type.Null()], {
+        description: "Project this trigger belongs to. Null when it is ecosystem-wide"
+      })
+    ),
+    source: triggerSourceSchema,
+    target: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.String({ maxLength: 255 }), typebox.Type.Null()], {
+        description: "Concrete model/designer/field the event refers to. Null for sourceless events"
+      })
+    ),
+    operation: typebox.Type.Optional(
+      typebox.Type.Union([triggerOperationSchema, typebox.Type.Null()], {
+        description: "Operation on the target that fires the trigger. Null when not applicable"
+      })
+    ),
+    conditions: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Object({}, { additionalProperties: true }), typebox.Type.Null()], {
+        description: "jsonLogic conditions (root object) evaluated to decide whether the trigger runs"
+      })
+    ),
+    relations: typebox.Type.Optional(
+      typebox.Type.Union([triggerRelationsSchema, typebox.Type.Null()], {
+        description: "Related models loaded into the context before evaluating the conditions and running the actions. Null means none."
+      })
+    ),
+    enabled: typebox.Type.Optional(typebox.Type.Boolean({ description: "Whether the trigger is active" })),
+    retention_days: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Number(), typebox.Type.Null()], {
+        description: "Retention in days for the process_log entries of this trigger (issue #175). Origin — no inheritance: null or 0 = disabled (never expires); N (>0) = enabled (expires N days after write)."
+      })
+    )
+  },
+  { title: "AutomaticTrigger", description: "Automatic trigger definition (ecosystem level)" }
+);
+const includeActionsQuerySchema = typebox.Type.Object(
+  {
+    includeActions: typebox.Type.Optional(
+      typebox.Type.Boolean({
+        default: false,
+        description: "Return each trigger with its ordered `actions` resolved, in a single request"
+      })
+    )
+  },
+  { title: "IncludeActionsQuery", description: "Opt-in flag to embed the actions of a trigger" }
+);
+const createAutomaticTriggerSchema = typebox.Type.Object(
+  {
+    source: triggerSourceSchema,
+    target: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.String({ maxLength: 255 }), typebox.Type.Null()], {
+        description: "Concrete model/designer/field the event refers to. Null for sourceless events"
+      })
+    ),
+    operation: typebox.Type.Optional(
+      typebox.Type.Union([triggerOperationSchema, typebox.Type.Null()], {
+        description: "Operation on the target that fires the trigger. Null when not applicable"
+      })
+    ),
+    conditions: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Object({}, { additionalProperties: true }), typebox.Type.Null()], {
+        description: "jsonLogic conditions (root object) evaluated to decide whether the trigger runs"
+      })
+    ),
+    relations: typebox.Type.Optional(
+      typebox.Type.Union([triggerRelationsSchema, typebox.Type.Null()], {
+        description: "Related models loaded into the context before evaluating the conditions and running the actions. Null means none."
+      })
+    ),
+    enabled: typebox.Type.Optional(typebox.Type.Boolean({ description: "Whether the trigger is active" })),
+    retention_days: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Number(), typebox.Type.Null()], {
+        description: "Retention in days for the process_log entries of this trigger (issue #175). Origin — no inheritance: null or 0 = disabled (never expires); N (>0) = enabled (expires N days after write)."
+      })
+    ),
+    actions: typebox.Type.Optional(triggerActionsInputSchema)
+  },
+  {
+    title: "CreateAutomaticTrigger",
+    description: "Payload used to create an automatic trigger, optionally with the actions it runs",
+    additionalProperties: false
+  }
+);
+const updateAutomaticTriggerSchema = typebox.Type.Partial(createAutomaticTriggerSchema, {
+  title: "UpdateAutomaticTrigger",
+  description: "Payload used to update an automatic trigger, optionally replacing the actions it runs",
+  additionalProperties: false
+});
+const UnmatchedBehavior = {
+  HIDE: "hide",
+  DISABLE: "disable"
+};
+const unmatchedBehaviorSchema = typebox.Type.Enum(Object.values(UnmatchedBehavior), {
+  title: "UnmatchedBehavior",
+  description: "What to do with the button when the trigger does not match: hide it or disable it"
+});
+const IconPosition = {
+  LEFT: "left",
+  RIGHT: "right"
+};
+const iconPositionSchema = typebox.Type.Enum(Object.values(IconPosition), {
+  title: "IconPosition",
+  description: "Side of the label the icon sits on"
+});
+const manualTriggerButtonStyleSchema = typebox.Type.Object(
+  {
+    text: typebox.Type.Optional(typebox.Type.String({ description: "Handlebars template rendered as the button label" })),
+    textColor: typebox.Type.Optional(typebox.Type.String({ description: "Label colour" })),
+    bgColor: typebox.Type.Optional(typebox.Type.String({ description: "Background colour" })),
+    icon: typebox.Type.Optional(typebox.Type.String({ description: "Icon name, resolved by the consumer" })),
+    iconPosition: typebox.Type.Optional(iconPositionSchema)
+  },
+  { title: "ManualTriggerButtonStyle", description: "Presentation of the button a manual trigger is offered on" }
+);
+const manualTriggerConditionalStyleSchema = typebox.Type.Intersect(
+  [
+    manualTriggerButtonStyleSchema,
+    typebox.Type.Object({
+      conditions: typebox.Type.Optional(
+        typebox.Type.Union([typebox.Type.Object({}, { additionalProperties: true }), typebox.Type.Null()], {
+          description: "jsonLogic conditions selecting this style. Absent or null always applies"
+        })
+      ),
+      continueEvaluate: typebox.Type.Optional(
+        typebox.Type.Boolean({ description: "Keep evaluating later entries after this one matches" })
+      )
+    })
+  ],
+  { title: "ManualTriggerConditionalStyle" }
+);
+const manualTriggerConfigSchema = typebox.Type.Object(
+  {
+    unmatchedBehavior: typebox.Type.Optional(unmatchedBehaviorSchema),
+    styles: typebox.Type.Optional(manualTriggerButtonStyleSchema),
+    conditionalStyles: typebox.Type.Optional(typebox.Type.Array(manualTriggerConditionalStyleSchema))
+  },
+  { title: "ManualTriggerConfig", additionalProperties: true }
+);
+const manualTriggerSchema = typebox.Type.Object(
+  {
+    id: typebox.Type.Number({ description: "Unique identifier of the manual trigger" }),
+    project_id: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Number(), typebox.Type.Null()], {
+        description: "Project this trigger belongs to. Null when it is ecosystem-wide"
+      })
+    ),
+    name: typebox.Type.String({ maxLength: 255, description: "Human-readable label of the trigger where it is offered" }),
+    source: triggerSourceSchema,
+    target: typebox.Type.String({
+      maxLength: 255,
+      description: "Concrete model/designer/field the trigger is bound to. Always set: there is no wildcard"
+    }),
+    conditions: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Object({}, { additionalProperties: true }), typebox.Type.Null()], {
+        description: "jsonLogic conditions (root object) evaluated to decide whether the trigger runs. Evaluated against the selected entity and the request context; `old` is always null, because the trigger is invoked explicitly and there is no previous state to compare against."
+      })
+    ),
+    relations: typebox.Type.Optional(
+      typebox.Type.Union([triggerRelationsSchema, typebox.Type.Null()], {
+        description: "Related models loaded into the context before evaluating the conditions and running the actions. Null means none."
+      })
+    ),
+    enabled: typebox.Type.Optional(typebox.Type.Boolean({ description: "Whether the trigger is active" })),
+    retention_days: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Number(), typebox.Type.Null()], {
+        description: "Retention in days for the process_log entries of this trigger (issue #175). Origin — no inheritance: null or 0 = disabled (never expires); N (>0) = enabled (expires N days after write)."
+      })
+    ),
+    config: typebox.Type.Optional(
+      typebox.Type.Union([manualTriggerConfigSchema, typebox.Type.Null()], {
+        description: "Configuration of the trigger beyond its firing rules. Null means none"
+      })
+    )
+  },
+  { title: "ManualTrigger", description: "Manual trigger definition (ecosystem level)" }
+);
+const createManualTriggerSchema = typebox.Type.Object(
+  {
+    name: typebox.Type.String({ maxLength: 255, description: "Human-readable label of the trigger where it is offered" }),
+    source: triggerSourceSchema,
+    target: typebox.Type.String({
+      maxLength: 255,
+      description: "Concrete model/designer/field the trigger is bound to. Always set: there is no wildcard"
+    }),
+    conditions: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Object({}, { additionalProperties: true }), typebox.Type.Null()], {
+        description: "jsonLogic conditions (root object) evaluated to decide whether the trigger runs. Evaluated against the selected entity and the request context; `old` is always null, because the trigger is invoked explicitly and there is no previous state to compare against."
+      })
+    ),
+    relations: typebox.Type.Optional(
+      typebox.Type.Union([triggerRelationsSchema, typebox.Type.Null()], {
+        description: "Related models loaded into the context before evaluating the conditions and running the actions. Null means none."
+      })
+    ),
+    enabled: typebox.Type.Optional(typebox.Type.Boolean({ description: "Whether the trigger is active" })),
+    retention_days: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.Number(), typebox.Type.Null()], {
+        description: "Retention in days for the process_log entries of this trigger (issue #175). Origin — no inheritance: null or 0 = disabled (never expires); N (>0) = enabled (expires N days after write)."
+      })
+    ),
+    config: typebox.Type.Optional(
+      typebox.Type.Union([manualTriggerConfigSchema, typebox.Type.Null()], {
+        description: "Configuration of the trigger beyond its firing rules. Null means none"
+      })
+    ),
+    actions: typebox.Type.Optional(triggerActionsInputSchema)
+  },
+  {
+    title: "CreateManualTrigger",
+    description: "Payload used to create a manual trigger, optionally with the actions it runs",
+    additionalProperties: false
+  }
+);
+const updateManualTriggerSchema = typebox.Type.Partial(createManualTriggerSchema, {
+  title: "UpdateManualTrigger",
+  description: "Payload used to update a manual trigger, optionally replacing the actions it runs",
+  additionalProperties: false
+});
+const manualTriggerAvailabilitySchema = typebox.Type.Object(
+  {
+    id: typebox.Type.Number({ description: "Identifier of the manual trigger" }),
+    name: typebox.Type.String({ description: "Human-readable label of the trigger" }),
+    matched: typebox.Type.Boolean({
+      description: "Whether the trigger conditions hold for this entity right now. A trigger with no conditions always matches. False means the button is shown disabled: triggers configured to hide when unmatched are not listed"
+    }),
+    actionsCount: typebox.Type.Number({ description: "Number of actions the trigger would run" }),
+    relationsSkipped: typebox.Type.Optional(
+      typebox.Type.Union([typebox.Type.String(), typebox.Type.Null()], {
+        description: "Reason the declared relations could not be loaded before evaluating, when that happened. Null otherwise"
+      })
+    ),
+    /**
+     * Resolved server-side: conditional styles already evaluated and label already compiled. Absent
+     * when the trigger has no config — the consumer then paints its own default button.
+     */
+    style: typebox.Type.Optional(manualTriggerButtonStyleSchema)
+  },
+  {
+    title: "ManualTriggerAvailability",
+    description: "A manual trigger applicable to an entity, with its conditions already evaluated"
+  }
+);
+const manualTriggerAvailabilityListSchema = typebox.Type.Object(
+  { results: typebox.Type.Array(manualTriggerAvailabilitySchema, { description: "Applicable manual triggers" }) },
+  {
+    title: "ManualTriggerAvailabilityList",
+    description: "Manual triggers applicable to an entity, with their conditions evaluated"
+  }
+);
+const manualTriggerAvailabilityQuerySchema = typebox.Type.Object(
+  {
+    source: triggerSourceSchema,
+    target: typebox.Type.String({ maxLength: 255, description: "Concrete model/designer/field the triggers are bound to" }),
+    entityId: typebox.Type.Number({ description: "Identifier of the entity the triggers would run against" })
+  },
+  { title: "ManualTriggerAvailabilityQuery", description: "Entity the applicable manual triggers are listed for" }
+);
+const runManualTriggerSchema = typebox.Type.Object(
+  { entityId: typebox.Type.Number({ description: "Identifier of the entity to run the trigger against" }) },
+  { title: "RunManualTrigger", description: "Payload used to run a manual trigger against an entity" }
+);
+const automaticTriggerActionSchema = typebox.Type.Object(
+  {
+    id: typebox.Type.Number({ description: "Unique identifier of the trigger-action link" }),
+    automatic_trigger_id: typebox.Type.Number({
+      description: "Automatic trigger executing the action (FK to automatic_trigger)"
+    }),
+    action_id: typebox.Type.Number({ description: "Action executed by the trigger (FK to actions)" }),
+    execution_order: typebox.Type.Number({ description: "Execution order of the action within the trigger" })
+  },
+  { title: "AutomaticTriggerAction", description: "Ordered link between an automatic trigger and an action" }
+);
+const createAutomaticTriggerActionSchema = typebox.Type.Omit(automaticTriggerActionSchema, ["id"], {
+  title: "CreateAutomaticTriggerAction",
+  description: "Row shape of an automatic trigger-action link"
+});
+const updateAutomaticTriggerActionSchema = typebox.Type.Partial(createAutomaticTriggerActionSchema, {
+  title: "UpdateAutomaticTriggerAction",
+  description: "Partial row shape of an automatic trigger-action link"
+});
+const manualTriggerActionSchema = typebox.Type.Object(
+  {
+    id: typebox.Type.Number({ description: "Unique identifier of the trigger-action link" }),
+    manual_trigger_id: typebox.Type.Number({
+      description: "Manual trigger executing the action (FK to manual_trigger)"
+    }),
+    action_id: typebox.Type.Number({ description: "Action executed by the trigger (FK to actions)" }),
+    execution_order: typebox.Type.Number({ description: "Execution order of the action within the trigger" })
+  },
+  { title: "ManualTriggerAction", description: "Ordered link between a manual trigger and an action" }
+);
+const createManualTriggerActionSchema = typebox.Type.Omit(manualTriggerActionSchema, ["id"], {
+  title: "CreateManualTriggerAction",
+  description: "Row shape of a manual trigger-action link"
+});
+const updateManualTriggerActionSchema = typebox.Type.Partial(createManualTriggerActionSchema, {
+  title: "UpdateManualTriggerAction",
+  description: "Partial row shape of a manual trigger-action link"
+});
+const withResolvedActions = typebox.Type.Object({
+  actions: typebox.Type.Optional(typebox.Type.Array(actionSchema, { description: "Actions the trigger runs, in execution order" }))
+});
+const automaticTriggerWithActionsSchema = typebox.Type.Intersect([automaticTriggerSchema, withResolvedActions], {
+  title: "AutomaticTriggerWithActions",
+  description: "An automatic trigger and, when the request wrote them or `includeActions` asked for them, the actions it runs"
+});
+const manualTriggerWithActionsSchema = typebox.Type.Intersect([manualTriggerSchema, withResolvedActions], {
+  title: "ManualTriggerWithActions",
+  description: "A manual trigger and, when the request wrote them or `includeActions` asked for them, the actions it runs"
+});
+const triggerExecutionResultSchema = typebox.Type.Object(
+  {
+    triggerId: typebox.Type.Number({ description: "Identifier of the evaluated trigger" }),
+    matched: typebox.Type.Boolean({ description: "Whether the conditions held, so the actions were run" }),
+    actionsRun: typebox.Type.Number({ description: "Number of actions that were executed" }),
+    actionsAborted: typebox.Type.Number({ description: "Number of actions aborted by context validation" })
+  },
+  { title: "TriggerExecutionResult", description: "Outcome of evaluating and running one trigger" }
+);
+const successResponseSchema = typebox.Type.Object(
+  { success: typebox.Type.Boolean({ description: "If the request success or not" }) },
+  { title: "ActionSystemSuccessResponse", description: "Response when the request is successful" }
+);
+const withIdParamsSchema = typebox.Type.Intersect(
+  [ecosystemProjectParamsSchema, typebox.Type.Object({ id: typebox.Type.Number({ description: "Entity ID" }) })],
+  { title: "EcosystemProjectWithActionSystemIdParams", description: "Params with ecosystem, project and entity ID" }
+);
+exports.ACTION_CONFIG_SCHEMAS = ACTION_CONFIG_SCHEMAS;
+exports.ACTION_CONTEXT_SCHEMAS = ACTION_CONTEXT_SCHEMAS;
+exports.ActionType = ActionType;
+exports.ConditionsFormat = ConditionsFormat;
+exports.IconPosition = IconPosition;
+exports.TriggerOperation = TriggerOperation;
+exports.TriggerSource = TriggerSource;
+exports.UnmatchedBehavior = UnmatchedBehavior;
+exports.actionConfigBaseSchema = actionConfigBaseSchema;
+exports.actionConfigSchema = actionConfigSchema;
+exports.actionContextBaseSchema = actionContextBaseSchema;
+exports.actionSchema = actionSchema;
+exports.actionTypeSchema = actionTypeSchema;
+exports.apiActionConfigSchema = apiActionConfigSchema;
+exports.apiActionContextSchema = apiActionContextSchema;
+exports.automaticTriggerActionSchema = automaticTriggerActionSchema;
+exports.automaticTriggerSchema = automaticTriggerSchema;
+exports.automaticTriggerWithActionsSchema = automaticTriggerWithActionsSchema;
+exports.conditionsFormatSchema = conditionsFormatSchema;
+exports.createActionSchema = createActionSchema;
+exports.createAutomaticTriggerActionSchema = createAutomaticTriggerActionSchema;
+exports.createAutomaticTriggerSchema = createAutomaticTriggerSchema;
+exports.createManualTriggerActionSchema = createManualTriggerActionSchema;
+exports.createManualTriggerSchema = createManualTriggerSchema;
+exports.iconPositionSchema = iconPositionSchema;
+exports.includeActionsQuerySchema = includeActionsQuerySchema;
+exports.manualTriggerActionSchema = manualTriggerActionSchema;
+exports.manualTriggerAvailabilityListSchema = manualTriggerAvailabilityListSchema;
+exports.manualTriggerAvailabilityQuerySchema = manualTriggerAvailabilityQuerySchema;
+exports.manualTriggerAvailabilitySchema = manualTriggerAvailabilitySchema;
+exports.manualTriggerButtonStyleSchema = manualTriggerButtonStyleSchema;
+exports.manualTriggerConditionalStyleSchema = manualTriggerConditionalStyleSchema;
+exports.manualTriggerConfigSchema = manualTriggerConfigSchema;
+exports.manualTriggerSchema = manualTriggerSchema;
+exports.manualTriggerWithActionsSchema = manualTriggerWithActionsSchema;
+exports.runManualTriggerSchema = runManualTriggerSchema;
+exports.successResponseSchema = successResponseSchema;
+exports.triggerActionInputSchema = triggerActionInputSchema;
+exports.triggerActionsInputSchema = triggerActionsInputSchema;
+exports.triggerExecutionResultSchema = triggerExecutionResultSchema;
+exports.triggerOperationSchema = triggerOperationSchema;
+exports.triggerRelationsSchema = triggerRelationsSchema;
+exports.triggerSourceSchema = triggerSourceSchema;
+exports.unmatchedBehaviorSchema = unmatchedBehaviorSchema;
+exports.updateActionSchema = updateActionSchema;
+exports.updateAutomaticTriggerActionSchema = updateAutomaticTriggerActionSchema;
+exports.updateAutomaticTriggerSchema = updateAutomaticTriggerSchema;
+exports.updateManualTriggerActionSchema = updateManualTriggerActionSchema;
+exports.updateManualTriggerSchema = updateManualTriggerSchema;
+exports.withIdParamsSchema = withIdParamsSchema;
+//# sourceMappingURL=ecosystem-action-system.cjs.map