diff --git a/include/crm/common/scheduler.h b/include/crm/common/scheduler.h
index 79419ea9d1..805c316786 100644
--- a/include/crm/common/scheduler.h
+++ b/include/crm/common/scheduler.h
@@ -1,167 +1,230 @@
 /*
  * Copyright 2004-2023 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU Lesser General Public License
  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
  */
 
 #ifndef PCMK__CRM_COMMON_SCHEDULER__H
 #  define PCMK__CRM_COMMON_SCHEDULER__H
 
+#include <sys/types.h>                  // time_t
+#include <libxml/tree.h>                // xmlNode
+#include <glib.h>                       // guint, GList, GHashTable
+
+#include <crm/common/iso8601.h>         // crm_time_t
+
 #include <crm/common/actions.h>
 #include <crm/common/nodes.h>
 #include <crm/common/resources.h>
 #include <crm/common/roles.h>
 #include <crm/common/scheduler_types.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /*!
  * \file
  * \brief Scheduler API
  * \ingroup core
  */
 
 //! Possible responses to loss of quorum
 enum pe_quorum_policy {
     pcmk_no_quorum_freeze,  //<! Do not recover resources from outside partition
     pcmk_no_quorum_stop,    //<! Stop all resources in partition
     pcmk_no_quorum_ignore,  //<! Act as if partition still holds quorum
     pcmk_no_quorum_fence,   //<! Fence all nodes in partition
     pcmk_no_quorum_demote,  //<! Demote promotable resources and stop all others
 
 #if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
     //! \deprecated Use pcmk_no_quorum_freeze instead
     no_quorum_freeze    = pcmk_no_quorum_freeze,
 
     //! \deprecated Use pcmk_no_quorum_stop instead
     no_quorum_stop      = pcmk_no_quorum_stop,
 
     //! \deprecated Use pcmk_no_quorum_ignore instead
     no_quorum_ignore    = pcmk_no_quorum_ignore,
 
     //! \deprecated Use pcmk_no_quorum_fence instead
     no_quorum_suicide   = pcmk_no_quorum_fence,
 
     //! \deprecated Use pcmk_no_quorum_demote instead
     no_quorum_demote    = pcmk_no_quorum_demote,
 #endif
 };
 
 //! Scheduling options and conditions
 enum pcmk_scheduler_flags {
     //! No scheduler flags set (compare with equality rather than bit set)
     pcmk_sched_none                     = 0ULL,
 
     // These flags are dynamically determined conditions
 
     //! Whether partition has quorum (via have-quorum property)
     pcmk_sched_quorate                  = (1ULL << 0),
 
     //! Whether cluster is symmetric (via symmetric-cluster property)
     pcmk_sched_symmetric_cluster        = (1ULL << 1),
 
     //! Whether cluster is in maintenance mode (via maintenance-mode property)
     pcmk_sched_in_maintenance           = (1ULL << 3),
 
     //! Whether fencing is enabled (via stonith-enabled property)
     pcmk_sched_fencing_enabled          = (1ULL << 4),
 
     //! Whether cluster has a fencing resource (via CIB resources)
     pcmk_sched_have_fencing             = (1ULL << 5),
 
     //! Whether any resource provides or requires unfencing (via CIB resources)
     pcmk_sched_enable_unfencing         = (1ULL << 6),
 
     //! Whether concurrent fencing is allowed (via concurrent-fencing property)
     pcmk_sched_concurrent_fencing       = (1ULL << 7),
 
     /*!
      * Whether resources removed from the configuration should be stopped (via
      * stop-orphan-resources property)
      */
     pcmk_sched_stop_removed_resources   = (1ULL << 8),
 
     /*!
      * Whether recurring actions removed from the configuration should be
      * cancelled (via stop-orphan-actions property)
      */
     pcmk_sched_cancel_removed_actions   = (1ULL << 9),
 
     //! Whether to stop all resources (via stop-all-resources property)
     pcmk_sched_stop_all                 = (1ULL << 10),
 
     /*!
      * Whether start failure should be treated as if migration-threshold is 1
      * (via start-failure-is-fatal property)
      */
     pcmk_sched_start_failure_fatal      = (1ULL << 12),
 
     //! \deprecated Do not use
     pcmk_sched_remove_after_stop        = (1ULL << 13),
 
     //! Whether unseen nodes should be fenced (via startup-fencing property)
     pcmk_sched_startup_fencing          = (1ULL << 14),
 
     /*!
      * Whether resources should be left stopped when their node shuts down
      * cleanly (via shutdown-lock property)
      */
     pcmk_sched_shutdown_lock            = (1ULL << 15),
 
     /*!
      * Whether resources' current state should be probed (when unknown) before
      * scheduling any other actions (via the enable-startup-probes property)
      */
     pcmk_sched_probe_resources          = (1ULL << 16),
 
     //! Whether the CIB status section has been parsed yet
     pcmk_sched_have_status              = (1ULL << 17),
 
     //! Whether the cluster includes any Pacemaker Remote nodes (via CIB)
     pcmk_sched_have_remote_nodes        = (1ULL << 18),
 
     // The remaining flags are scheduling options that must be set explicitly
 
     /*!
      * Whether to skip unpacking the CIB status section and stop the scheduling
      * sequence after applying node-specific location criteria (skipping
      * assignment, ordering, actions, etc.).
      */
     pcmk_sched_location_only            = (1ULL << 20),
 
     //! Whether sensitive resource attributes have been masked
     pcmk_sched_sanitized                = (1ULL << 21),
 
     //! Skip counting of total, disabled, and blocked resource instances
     pcmk_sched_no_counts                = (1ULL << 23),
 
     /*!
      * Skip deprecated code kept solely for backward API compatibility
      * (internal code should always set this)
      */
     pcmk_sched_no_compat                = (1ULL << 24),
 
     //! Whether node scores should be output instead of logged
     pcmk_sched_output_scores            = (1ULL << 25),
 
     //! Whether to show node and resource utilization (in log or output)
     pcmk_sched_show_utilization         = (1ULL << 26),
 
     /*!
      * Whether to stop the scheduling sequence after unpacking the CIB,
      * calculating cluster status, and applying node health (skipping
      * applying node-specific location criteria, assignment, etc.)
      */
     pcmk_sched_validate_only            = (1ULL << 27),
 };
 
+//! Implementation of pcmk_scheduler_t
+struct pe_working_set_s {
+    // Be careful about when each piece of information is available and final
+
+    xmlNode *input;                 //!< CIB XML
+    crm_time_t *now;                //!< Current time for evaluation purposes
+    char *dc_uuid;                  //!< Node ID of designated controller
+    pcmk_node_t *dc_node;           //!< Node object for DC
+    const char *stonith_action;     //!< Default fencing action
+    const char *placement_strategy; //!< Value of placement-strategy property
+    unsigned long long flags;       //!< Group of enum pcmk_scheduler_flags
+    int stonith_timeout;            //!< Value of stonith-timeout property
+    enum pe_quorum_policy no_quorum_policy; //!< Response to loss of quorum
+    GHashTable *config_hash;        //!< Cluster properties
+
+    //!< Ticket constraints unpacked from ticket state
+    GHashTable *tickets;
+
+    //! Actions for which there can be only one (such as "fence node X")
+    GHashTable *singletons;
+
+    GList *nodes;                   //!< Nodes in cluster
+    GList *resources;               //!< Resources in cluster
+    GList *placement_constraints;   //!< Location constraints
+    GList *ordering_constraints;    //!< Ordering constraints
+    GList *colocation_constraints;  //!< Colocation constraints
+
+    //!< Ticket constraints unpacked by libpacemaker
+    GList *ticket_constraints;
+
+    GList *actions;                 //!< Scheduled actions
+    xmlNode *failed;                //!< History entries of failed actions
+    xmlNode *op_defaults;           //!< Configured operation defaults
+    xmlNode *rsc_defaults;          //!< Configured resource defaults
+    int num_synapse;                //!< Number of transition graph synapses
+    int max_valid_nodes;            //!< \deprecated Do not use
+    int order_id;                   //!< ID to use for next created ordering
+    int action_id;                  //!< ID to use for next created action
+    xmlNode *graph;                 //!< Transition graph
+    GHashTable *template_rsc_sets;  //!< Mappings of template ID to resource ID
+    const char *localhost;          //!< Node will be created for this if needed
+    GHashTable *tags;               //!< Configuration tags (ID -> pe_tag_t *)
+    int blocked_resources;          //!< Number of blocked resources in cluster
+    int disabled_resources;         //!< Number of disabled resources in cluster
+    GList *param_check;             //!< History entries that need to be checked
+    GList *stop_needed;             //!< Containers that need stop actions
+    time_t recheck_by;              //!< Hint to controller when to reschedule
+    int ninstances;                 //!< Total number of resource instances
+    guint shutdown_lock;            //!< How long to lock resources (seconds)
+    int priority_fencing_delay;     //!< Priority fencing delay
+
+    // pcmk__output_t *
+    void *priv;                     //!< For Pacemaker use only
+
+    guint node_pending_timeout;     //!< Pending join times out after this (ms)
+};
+
 #ifdef __cplusplus
 }
 #endif
 
 #endif // PCMK__CRM_COMMON_SCHEDULER__H
diff --git a/include/crm/pengine/pe_types.h b/include/crm/pengine/pe_types.h
index dd8c528fae..0726d8e95d 100644
--- a/include/crm/pengine/pe_types.h
+++ b/include/crm/pengine/pe_types.h
@@ -1,218 +1,158 @@
 /*
  * Copyright 2004-2023 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU Lesser General Public License
  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
  */
 
 #ifndef PCMK__CRM_PENGINE_PE_TYPES__H
 #  define PCMK__CRM_PENGINE_PE_TYPES__H
 
 
 #  include <stdbool.h>              // bool
 #  include <sys/types.h>            // time_t
 #  include <libxml/tree.h>          // xmlNode
 #  include <glib.h>                 // gboolean, guint, GList, GHashTable
 #  include <crm/common/iso8601.h>
 #  include <crm/common/scheduler.h>
 #  include <crm/pengine/common.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /*!
  * \file
  * \brief Data types for cluster status
  * \ingroup pengine
  */
 
-struct pe_working_set_s {
-    xmlNode *input;
-    crm_time_t *now;
-
-    /* options extracted from the input */
-    char *dc_uuid;
-    pcmk_node_t *dc_node;
-    const char *stonith_action;
-    const char *placement_strategy;
-
-    unsigned long long flags;
-
-    int stonith_timeout;
-    enum pe_quorum_policy no_quorum_policy;
-
-    GHashTable *config_hash;
-    GHashTable *tickets;
-
-    // Actions for which there can be only one (e.g. fence nodeX)
-    GHashTable *singletons;
-
-    GList *nodes;
-    GList *resources;
-    GList *placement_constraints;
-    GList *ordering_constraints;
-    GList *colocation_constraints;
-    GList *ticket_constraints;
-
-    GList *actions;
-    xmlNode *failed;
-    xmlNode *op_defaults;
-    xmlNode *rsc_defaults;
-
-    /* stats */
-    int num_synapse;
-    int max_valid_nodes;    //! Deprecated (will be removed in a future release)
-    int order_id;
-    int action_id;
-
-    /* final output */
-    xmlNode *graph;
-
-    GHashTable *template_rsc_sets;
-    const char *localhost;
-    GHashTable *tags;
-
-    int blocked_resources;
-    int disabled_resources;
-
-    GList *param_check; // History entries that need to be checked
-    GList *stop_needed; // Containers that need stop actions
-    time_t recheck_by;  // Hint to controller to re-run scheduler by this time
-    int ninstances;     // Total number of resource instances
-    guint shutdown_lock;// How long (seconds) to lock resources to shutdown node
-    int priority_fencing_delay; // Priority fencing delay
-
-    void *priv;
-    guint node_pending_timeout; // Node pending timeout
-};
-
 struct pe_action_s {
     int id;
     int priority;
 
     pcmk_resource_t *rsc;
     pcmk_node_t *node;
     xmlNode *op_entry;
 
     char *task;
     char *uuid;
     char *cancel_task;
     char *reason;
 
     enum pe_action_flags flags;
     enum rsc_start_requirement needs;
     enum action_fail_response on_fail;
     enum rsc_role_e fail_role;
 
     GHashTable *meta;
     GHashTable *extra;
 
     /* 
      * These two varables are associated with the constraint logic
      * that involves first having one or more actions runnable before
      * then allowing this action to execute.
      *
      * These varables are used with features such as 'clone-min' which
      * requires at minimum X number of cloned instances to be running
      * before an order dependency can run. Another option that uses
      * this is 'require-all=false' in ordering constrants. This option
      * says "only require one instance of a resource to start before
      * allowing dependencies to start" -- basically, require-all=false is
      * the same as clone-min=1.
      */
 
     /* current number of known runnable actions in the before list. */
     int runnable_before;
     /* the number of "before" runnable actions required for this action
      * to be considered runnable */ 
     int required_runnable_before;
 
     GList *actions_before;    /* pe_action_wrapper_t* */
     GList *actions_after;     /* pe_action_wrapper_t* */
 
     /* Some of the above fields could be moved to the details,
      * except for API backward compatibility.
      */
     void *action_details; // varies by type of action
 };
 
 typedef struct pe_ticket_s {
     char *id;
     gboolean granted;
     time_t last_granted;
     gboolean standby;
     GHashTable *state;
 } pe_ticket_t;
 
 typedef struct pe_tag_s {
     char *id;
     GList *refs;
 } pe_tag_t;
 
 //!@{
 //! \deprecated Do not use
 enum pe_ordering {
     pe_order_none                  = 0x0,       /* deleted */
 #if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
     pe_order_optional              = 0x1,       /* pure ordering, nothing implied */
     pe_order_apply_first_non_migratable = 0x2,  /* Only apply this constraint's ordering if first is not migratable. */
 
     pe_order_implies_first         = 0x10,      /* If 'then' is required, ensure 'first' is too */
     pe_order_implies_then          = 0x20,      /* If 'first' is required, ensure 'then' is too */
     pe_order_promoted_implies_first = 0x40,     /* If 'then' is required and then's rsc is promoted, ensure 'first' becomes required too */
 
     /* first requires then to be both runnable and migrate runnable. */
     pe_order_implies_first_migratable  = 0x80,
 
     pe_order_runnable_left         = 0x100,     /* 'then' requires 'first' to be runnable */
 
     pe_order_pseudo_left           = 0x200,     /* 'then' can only be pseudo if 'first' is runnable */
     pe_order_implies_then_on_node  = 0x400,     /* If 'first' is required on 'nodeX',
                                                  * ensure instances of 'then' on 'nodeX' are too.
                                                  * Only really useful if 'then' is a clone and 'first' is not
                                                  */
     pe_order_probe                 = 0x800,     /* If 'first->rsc' is
                                                  *  - running but about to stop, ignore the constraint
                                                  *  - otherwise, behave as runnable_left
                                                  */
 
     pe_order_restart               = 0x1000,    /* 'then' is runnable if 'first' is optional or runnable */
     pe_order_stonith_stop          = 0x2000,
     pe_order_serialize_only        = 0x4000,    /* serialize */
     pe_order_same_node             = 0x8000,    /* applies only if 'first' and 'then' are on same node */
 
     pe_order_implies_first_printed = 0x10000,   /* Like ..implies_first but only ensures 'first' is printed, not mandatory */
     pe_order_implies_then_printed  = 0x20000,   /* Like ..implies_then but only ensures 'then' is printed, not mandatory */
 
     pe_order_asymmetrical          = 0x100000,  /* Indicates asymmetrical one way ordering constraint. */
     pe_order_load                  = 0x200000,  /* Only relevant if... */
     pe_order_one_or_more           = 0x400000,  /* 'then' is runnable only if one or more of its dependencies are too */
     pe_order_anti_colocation       = 0x800000,
 
     pe_order_preserve              = 0x1000000, /* Hack for breaking user ordering constraints with container resources */
     pe_order_then_cancels_first    = 0x2000000, // if 'then' becomes required, 'first' becomes optional
     pe_order_trace                 = 0x4000000, /* test marker */
 
     pe_order_implies_first_master  = pe_order_promoted_implies_first,
 #endif
 };
 //!@}
 
 typedef struct pe_action_wrapper_s {
     enum pe_ordering type;
     enum pe_link_state state;
     pcmk_action_t *action;
 } pe_action_wrapper_t;
 
 #if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
 #include <crm/pengine/pe_types_compat.h>
 #endif
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif // PCMK__CRM_PENGINE_PE_TYPES__H