diff --git a/config/schema/workbench_email.schema.yml b/config/schema/workbench_email.schema.yml
index 262657e..b33ab47 100644
--- a/config/schema/workbench_email.schema.yml
+++ b/config/schema/workbench_email.schema.yml
@@ -22,27 +22,17 @@ workbench_email.workbench_email_template.*:
     subject:
       type: label
       label: 'Subject'
-    roles:
+    recipient_types:
       type: sequence
-      label: 'Roles'
+      label: 'Enabled recipient types'
       sequence:
-        type: string
-        label: 'Role'
+        type: workbench_email_recipient_type
     bundles:
       type: sequence
       label: 'Bundles'
       sequence:
         type: string
         label: 'Bundle'
-    fields:
-      type: sequence
-      label: 'Mail fields'
-      sequence:
-        type: string
-        label: 'Field'
-    author:
-      type: boolean
-      label: 'Send to author'
     body:
       type: mapping
       label: 'Body'
@@ -53,3 +43,57 @@ workbench_email.workbench_email_template.*:
         format:
           type: string
           label: 'Format'
+    dependencies:
+      type: config_dependencies
+      label: 'Dependencies'
+
+workbench_email_recipient_type:
+  type: mapping
+  label: 'Recipient type'
+  mapping:
+    id:
+      type: string
+      label: 'ID'
+    provider:
+      type: string
+      label: 'Provider'
+    status:
+      type: boolean
+      label: 'Status'
+    settings:
+      type: workbench_email_recipient_type_settings.[%parent.id]
+
+# Default for plugins without any schema.
+workbench_email_recipient_type_settings.*:
+  type: mapping
+  label: 'Recipient type settings'
+
+workbench_email_recipient_type_settings.email:
+  type: mapping
+  mapping:
+    fields:
+      type: sequence
+      label: 'Email fields'
+      sequence:
+        type: string
+        label: 'Email field'
+
+workbench_email_recipient_type_settings.role:
+  type: mapping
+  mapping:
+    roles:
+      type: sequence
+      label: 'Restrict to the selected roles'
+      sequence:
+        type: string
+        label: 'Role'
+
+workbench_email_recipient_type_settings.entity_reference_user:
+  type: mapping
+  mapping:
+    fields:
+      type: sequence
+      label: 'Entity Reference fields'
+      sequence:
+        type: string
+        label: 'Entity Reference field'
diff --git a/src/Annotation/RecipientType.php b/src/Annotation/RecipientType.php
new file mode 100644
index 0000000..4d49166
--- /dev/null
+++ b/src/Annotation/RecipientType.php
@@ -0,0 +1,69 @@
+<?php
+
+namespace Drupal\workbench_email\Annotation;
+
+use Drupal\Component\Annotation\Plugin;
+
+/**
+ * Defines a Recipient type annotation object.
+ *
+ * Plugin Namespace: Plugin\workbench_email\RecipientType.
+ *
+ * @see \Drupal\workbench_email\RecipientTypePluginManager
+ * @see \Drupal\workbench_email\Plugin\RecipientTypeInterface
+ * @see \Drupal\workbench_email\Plugin\RecipientTypeBase
+ * @see plugin_api
+ *
+ * @Annotation
+ */
+class RecipientType extends Plugin {
+
+  /**
+   * The plugin ID.
+   *
+   * @var string
+   */
+  public $id;
+
+  /**
+   * The name of the provider that owns the recipient type.
+   *
+   * @var string
+   */
+  public $provider;
+
+  /**
+   * The human-readable name of the recipient type.
+   *
+   * This is used as an administrative summary of what the recipient type does.
+   *
+   * @var \Drupal\Core\Annotation\Translation
+   *
+   * @ingroup plugin_translatable
+   */
+  public $title;
+
+  /**
+   * Additional administrative information about the recipient type's behavior.
+   *
+   * @var \Drupal\Core\Annotation\Translation
+   *
+   * @ingroup plugin_translatable
+   */
+  public $description = '';
+
+  /**
+   * Whether this recipient type is enabled or disabled by default.
+   *
+   * @var bool
+   */
+  public $status = FALSE;
+
+  /**
+   * The default settings for the recipient type.
+   *
+   * @var array
+   */
+  public $settings = [];
+
+}
diff --git a/src/Entity/Template.php b/src/Entity/Template.php
index f904260..cf03208 100644
--- a/src/Entity/Template.php
+++ b/src/Entity/Template.php
@@ -2,7 +2,11 @@
 
 namespace Drupal\workbench_email\Entity;
 
+use Drupal\Component\Plugin\PluginInspectionInterface;
 use Drupal\Core\Config\Entity\ConfigEntityBase;
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\workbench_email\Plugin\RecipientTypeInterface;
+use Drupal\workbench_email\RecipientTypePluginCollection;
 use Drupal\workbench_email\TemplateInterface;
 
 /**
@@ -68,18 +72,29 @@ class Template extends ConfigEntityBase implements TemplateInterface {
   protected $subject;
 
   /**
-   * Fields to get email from.
+   * Configured recipient types for this template.
    *
-   * @var string[]
+   * An associative array of recipient types assigned to the email template,
+   * keyed by the instance ID of each recipient type and using the properties:
+   * - id: The plugin ID of the recipient type plugin instance.
+   * - provider: The name of the provider that owns the recipient type.
+   * - status: (optional) A Boolean indicating whether the recipient type is
+   *   enabled for the email template. Defaults to FALSE.
+   * - settings: (optional) An array of configured settings for the recipient
+   *   type.
+   *
+   * Use Template::recipientTypes() to access the actual recipient types.
+   *
+   * @var array
    */
-  protected $fields = [];
+  protected $recipient_types = [];
 
   /**
-   * Roles to send to.
+   * Holds the collection of recipient types that are attached to this template.
    *
-   * @var string[]
+   * @var \Drupal\workbench_email\RecipientTypePluginCollection
    */
-  protected $roles = [];
+  protected $recipientTypeCollection;
 
   /**
    * Entity bundles.
@@ -88,13 +103,6 @@ class Template extends ConfigEntityBase implements TemplateInterface {
    */
   protected $bundles = [];
 
-  /**
-   * Send to entity owner.
-   *
-   * @var bool
-   */
-  protected $author = FALSE;
-
   /**
    * {@inheritdoc}
    */
@@ -128,82 +136,83 @@ class Template extends ConfigEntityBase implements TemplateInterface {
   /**
    * {@inheritdoc}
    */
-  public function isAuthor() {
-    return $this->author;
-  }
-
-  /**
-   * {@inheritdoc}
-   */
-  public function setAuthor($author) {
-    $this->author = $author;
-    return $this;
+  public function recipientTypes($instance_id = NULL) {
+    if (!isset($this->recipientTypeCollection)) {
+      $this->recipientTypeCollection = new RecipientTypePluginCollection(\Drupal::service('plugin.manager.recipient_type'), $this->recipient_types);
+      $this->recipientTypeCollection->sort();
+    }
+    if (isset($instance_id)) {
+      return $this->recipientTypeCollection->get($instance_id);
+    }
+    return $this->recipientTypeCollection;
   }
 
   /**
    * {@inheritdoc}
    */
-  public function getFields() {
-    return $this->fields;
+  public function getPluginCollections() {
+    return ['recipient_types' => $this->recipientTypes()];
   }
 
   /**
    * {@inheritdoc}
    */
-  public function setFields(array $fields) {
-    $this->fields = $fields;
+  public function calculateDependencies() {
+    parent::calculateDependencies();
+    foreach ($this->bundles as $bundle) {
+      list($entity_type_id, $bundle_id) = explode(':', $bundle, 2);
+      $entity_type = \Drupal::entityTypeManager()->getDefinition($entity_type_id);
+      $bundle_config_dependency = $entity_type->getBundleConfigDependency($bundle_id);
+      $this->addDependency($bundle_config_dependency['type'], $bundle_config_dependency['name']);
+    }
     return $this;
   }
 
   /**
    * {@inheritdoc}
    */
-  public function getRoles() {
-    return $this->roles;
+  protected function calculatePluginDependencies(PluginInspectionInterface $instance) {
+    // Only add dependencies for plugins that are actually configured.
+    if (isset($this->recipient_types[$instance->getPluginId()])) {
+      parent::calculatePluginDependencies($instance);
+    }
   }
 
   /**
    * {@inheritdoc}
    */
-  public function setRoles(array $roles) {
-    $this->roles = $roles;
-    return $this;
+  public function getBundles() {
+    return $this->bundles;
   }
 
   /**
    * {@inheritdoc}
    */
-  public function calculateDependencies() {
-    parent::calculateDependencies();
-    foreach ($this->roles as $role) {
-      $this->addDependency('config', 'user.role.' . $role);
-    }
-    foreach ($this->fields as $field) {
-      list($entity_type, $field_name) = explode(':', $field, 2);
-      $this->addDependency('config', "field.storage.$entity_type.$field_name");
-    }
-    foreach ($this->bundles as $bundle) {
-      list($entity_type_id, $bundle_id) = explode(':', $bundle, 2);
-      $entity_type = \Drupal::entityTypeManager()->getDefinition($entity_type_id);
-      $bundle_config_dependency = $entity_type->getBundleConfigDependency($bundle_id);
-      $this->addDependency($bundle_config_dependency['type'], $bundle_config_dependency['name']);
-    }
+  public function setBundles(array $bundles) {
+    $this->bundles = $bundles;
     return $this;
   }
 
   /**
    * {@inheritdoc}
    */
-  public function getBundles() {
-    return $this->bundles;
+  public function getRecipients(ContentEntityInterface $entity) {
+    $recipients = [];
+    foreach ($this->recipient_types as $plugin_id => $config) {
+      $recipients = array_merge($recipients, $this->recipientTypes($plugin_id)->prepareRecipients($entity, $this));
+    }
+    return array_filter(array_unique($recipients));
   }
 
   /**
    * {@inheritdoc}
    */
-  public function setBundles($bundles) {
-    $this->bundles = $bundles;
-    return $this;
+  public function onDependencyRemoval(array $dependencies) {
+    // Give the parent method and each recipient type plugin a chance to react
+    // to removed dependencies and report if any of them made a change.
+    return array_reduce(iterator_to_array($this->recipientTypes()), function ($carry, RecipientTypeInterface $type) use ($dependencies) {
+      return $type->onDependencyRemoval($dependencies) || $carry;
+    }, parent::onDependencyRemoval($dependencies));
   }
 
 }
diff --git a/src/EventSubscriber/WorkbenchTransitionEventSubscriber.php b/src/EventSubscriber/WorkbenchTransitionEventSubscriber.php
index db7e022..c1a8cc9 100644
--- a/src/EventSubscriber/WorkbenchTransitionEventSubscriber.php
+++ b/src/EventSubscriber/WorkbenchTransitionEventSubscriber.php
@@ -7,7 +7,6 @@ use Drupal\Core\Entity\EntityTypeManagerInterface;
 use Drupal\Core\Plugin\PluginBase;
 use Drupal\Core\Queue\QueueFactory;
 use Drupal\Core\Session\AccountInterface;
-use Drupal\user\EntityOwnerInterface;
 use Drupal\workbench_email\QueuedEmail;
 use Drupal\workbench_email\TemplateInterface;
 use Drupal\workbench_moderation\Event\WorkbenchModerationEvents;
@@ -77,7 +76,7 @@ class WorkbenchTransitionEventSubscriber implements EventSubscriberInterface {
     ])) {
       // Filter out any that the user doesn't have access to or that don't have
       // any email templates.
-      $transitions = array_filter($transitions, function(ModerationStateTransitionInterface $transition) {
+      $transitions = array_filter($transitions, function (ModerationStateTransitionInterface $transition) {
         return $this->currentUser->hasPermission(sprintf('use %s transition', $transition->id())) && $transition->getThirdPartySetting('workbench_email', 'workbench_email_templates', []);
       });
       if (!$transitions) {
@@ -122,33 +121,7 @@ class WorkbenchTransitionEventSubscriber implements EventSubscriberInterface {
    *   Array of email addresses to send to.
    */
   protected function prepareRecipients(ContentEntityInterface $entity, TemplateInterface $template) {
-    $recipients = [];
-    if ($template->isAuthor() && $entity instanceof EntityOwnerInterface) {
-      if (!$entity->getOwner()->isAnonymous()) {
-        $recipients[] = $entity->getOwner()->getEmail();
-      }
-    }
-    foreach ($template->getRoles() as $role) {
-      foreach ($this->entityTypeManager->getStorage('user')->loadByProperties([
-        'roles' => $role,
-        'status' => 1,
-      ]) as $account) {
-        $recipients[] = $account->getEmail();
-      }
-    }
-    $fields = array_filter($template->getFields(), function($field_name) use ($entity) {
-      list($entity_type, $field_name) = explode(':', $field_name, 2);
-      return $entity_type === $entity->getEntityTypeId() && $entity->hasField($field_name) && !$entity->{$field_name}->isEmpty();
-    });
-    foreach ($fields as $field) {
-      list(, $field_name) = explode(':', $field, 2);
-      /** @var \Drupal\Core\Field\FieldItemInterface $field_item */
-      foreach ($entity->{$field_name} as $field_item) {
-        $recipients[] = $field_item->get('value')->getValue();
-      }
-    }
-    return array_filter(array_unique($recipients));
+    return $template->getRecipients($entity);
   }
 
-
 }
diff --git a/src/Form/TemplateForm.php b/src/Form/TemplateForm.php
index a837d4c..93245e3 100644
--- a/src/Form/TemplateForm.php
+++ b/src/Form/TemplateForm.php
@@ -9,9 +9,7 @@ use Drupal\Core\Entity\EntityTypeBundleInfoInterface;
 use Drupal\Core\Entity\EntityTypeInterface;
 use Drupal\Core\Entity\EntityTypeManagerInterface;
 use Drupal\Core\Form\FormStateInterface;
-use Drupal\field\Entity\FieldConfig;
-use Drupal\user\Entity\Role;
-use Drupal\user\RoleInterface;
+use Drupal\Core\Form\SubformState;
 use Drupal\workbench_moderation\ModerationInformationInterface;
 use Symfony\Component\DependencyInjection\ContainerInterface;
 
@@ -57,6 +55,10 @@ class TemplateForm extends EntityForm {
    *   Entity type manager.
    * @param \Drupal\Core\Entity\EntityFieldManagerInterface $entity_field_manager
    *   Entity field manager.
+   * @param \Drupal\Core\Entity\EntityTypeBundleInfoInterface $entity_bundle_info
+   *   The entity type bundle info.
+   * @param \Drupal\workbench_moderation\ModerationInformationInterface $moderation_info
+   *   The moderation info service.
    */
   public function __construct(EntityTypeManagerInterface $entity_type_manager, EntityFieldManagerInterface $entity_field_manager, EntityTypeBundleInfoInterface $entity_bundle_info, ModerationInformationInterface $moderation_info) {
     $this->entityTypeManager = $entity_type_manager;
@@ -69,7 +71,12 @@ class TemplateForm extends EntityForm {
    * {@inheritdoc}
    */
   public static function create(ContainerInterface $container) {
-    return new static($container->get('entity_type.manager'), $container->get('entity_field.manager'), $container->get('entity_type.bundle.info'), $container->get('workbench_moderation.moderation_information'));
+    return new static(
+      $container->get('entity_type.manager'),
+      $container->get('entity_field.manager'),
+      $container->get('entity_type.bundle.info'),
+      $container->get('workbench_moderation.moderation_information')
+    );
   }
 
   /**
@@ -109,9 +116,9 @@ class TemplateForm extends EntityForm {
     ];
 
     $default_body = $workbench_email_template->getBody() + [
-        'value' => '',
-        'format' => 'plain_text',
-      ];
+      'value' => '',
+      'format' => 'plain_text',
+    ];
     $form['body'] = [
       '#type' => 'text_format',
       '#title' => $this->t('Body'),
@@ -120,63 +127,41 @@ class TemplateForm extends EntityForm {
       '#format' => $default_body['format'],
       '#default_value' => $default_body['value'],
     ];
-    // Add the roles.
-    $roles = array_filter($this->entityTypeManager->getStorage('user_role')
-      ->loadMultiple(), function (RoleInterface $role) {
-      return !in_array($role->id(), [
-        RoleInterface::ANONYMOUS_ID,
-        RoleInterface::AUTHENTICATED_ID,
-      ], TRUE);
-    });
-    $role_options = array_map(function (RoleInterface $role) {
-      return $role->label();
-    }, $roles);
-    $form['recipients'] = [
-      '#type' => 'details',
-      '#title' => $this->t('Recipients'),
-      '#open' => TRUE,
-    ];
-    $form['recipients']['roles'] = [
+
+    // Recipient types.
+    $recipient_types = $workbench_email_template->recipientTypes();
+    $form['enabled_recipient_types'] = [
       '#type' => 'checkboxes',
-      '#title' => $this->t('Roles'),
-      '#description' => $this->t('Send to all users with selected roles'),
-      '#options' => $role_options,
-      '#default_value' => $workbench_email_template->getRoles(),
+      '#title' => $this->t('Enabled recipient types'),
+      '#required' => TRUE,
+      '#options' => [],
+      '#default_value' => [],
     ];
-    // Add the fields.
-    $fields = $this->entityFieldManager->getFieldMapByFieldType('email');
-    $field_options = [];
-    foreach ($fields as $entity_type_id => $entity_type_fields) {
-      $entity_type = $this->entityTypeManager->getDefinition($entity_type_id);
-      if (!$this->moderationInfo->isModeratableEntityType($entity_type)) {
-        // These fields are irrelevant, the entity type isn't moderated.
-        continue;
+    $form['recipient_types_settings'] = [
+      '#type' => 'vertical_tabs',
+      '#title' => $this->t('Recipient type configuration'),
+    ];
+    /** @var \Drupal\workbench_email\Plugin\RecipientTypeInterface $plugin */
+    foreach ($recipient_types as $plugin_id => $plugin) {
+      $form['enabled_recipient_types']['#options'][$plugin_id] = $plugin->getLabel();
+      if ($plugin->isEnabled()) {
+        $form['enabled_recipient_types']['#default_value'][$plugin_id] = $plugin_id;
       }
-      $base = $this->entityFieldManager->getBaseFieldDefinitions($entity_type_id);
-      foreach ($entity_type_fields as $field_name => $field_detail) {
-        if (in_array($field_name, array_keys($base), TRUE)) {
-          continue;
-        }
-        $sample_bundle = reset($field_detail['bundles']);
-        $sample_field = $this->entityTypeManager->getStorage('field_config')
-          ->load($entity_type_id . '.' . $sample_bundle . '.' . $field_name);
-        $field_options[$entity_type_id . ':' . $field_name] = $sample_field->label() . ' (' . $entity_type->getLabel() . ')';
+      if ($plugin->hasFormClass('configure')) {
+        $form['recipient_types']['settings'][$plugin_id] = [
+          '#tree' => TRUE,
+          '#type' => 'details',
+          '#open' => TRUE,
+          '#title' => $plugin->getLabel(),
+          '#group' => 'recipient_types_settings',
+          '#parents' => ['recipient_types', $plugin_id, 'settings'],
+        ];
+        $subform_state = SubformState::createForSubform($form['recipient_types']['settings'][$plugin_id], $form, $form_state);
+        $form['recipient_types']['settings'][$plugin_id] += $plugin->buildConfigurationForm($form['recipient_types']['settings'][$plugin_id], $subform_state);
       }
     }
-    $form['recipients']['fields'] = [
-      '#type' => 'checkboxes',
-      '#title' => $this->t('Email Fields'),
-      '#description' => $this->t('Send to mail address found in the selected fields'),
-      '#options' => $field_options,
-      '#default_value' => $workbench_email_template->getFields(),
-    ];
-    // Add the author flag.
-    $form['recipients']['author'] = [
-      '#type' => 'checkbox',
-      '#default_value' => $workbench_email_template->isAuthor(),
-      '#title' => $this->t('Author'),
-      '#description' => $this->t('Send to entity author/owner'),
-    ];
+
+    // Bundles.
     $bundle_options = [];
     foreach ($this->entityTypeManager->getDefinitions() as $entity_type) {
       if (!$this->moderationInfo->isModeratableEntityType($entity_type) || !($bundle_entity_type = $entity_type->getBundleEntityType())) {
@@ -204,11 +189,37 @@ class TemplateForm extends EntityForm {
     return $form;
   }
 
+  /**
+   * {@inheritdoc}
+   */
+  public function validateForm(array &$form, FormStateInterface $form_state) {
+    /** @var \Drupal\workbench_email\TemplateInterface $workbench_email_template */
+    $workbench_email_template = $this->entity;
+    $recipient_types = $workbench_email_template->recipientTypes();
+    /** @var \Drupal\workbench_email\Plugin\RecipientTypeInterface $plugin */
+    foreach ($recipient_types as $plugin_id => $plugin) {
+      if ($plugin->hasFormClass('configure')) {
+        $subform_state = SubformState::createForSubform($form['recipient_types']['settings'][$plugin_id], $form, $form_state);
+        $plugin->validateConfigurationForm($form['recipient_types']['settings'][$plugin_id], $subform_state);
+      }
+    }
+    parent::validateForm($form, $form_state);
+  }
+
   /**
    * {@inheritdoc}
    */
   public function save(array $form, FormStateInterface $form_state) {
+    /** @var \Drupal\workbench_email\TemplateInterface $workbench_email_template */
     $workbench_email_template = $this->entity;
+    $recipient_types = $workbench_email_template->recipientTypes();
+    /** @var \Drupal\workbench_email\Plugin\RecipientTypeInterface $plugin */
+    foreach ($recipient_types as $plugin_id => $plugin) {
+      if ($plugin->hasFormClass('configure')) {
+        $subform_state = SubformState::createForSubform($form['recipient_types']['settings'][$plugin_id], $form, $form_state);
+        $plugin->submitConfigurationForm($form['recipient_types']['settings'][$plugin_id], $subform_state);
+      }
+    }
     $status = $workbench_email_template->save();
 
     switch ($status) {
@@ -232,8 +243,18 @@ class TemplateForm extends EntityForm {
   protected function copyFormValuesToEntity(EntityInterface $entity, array $form, FormStateInterface $form_state) {
     parent::copyFormValuesToEntity($entity, $form, $form_state);
     // Filter out unchecked items.
-    $entity->set('roles', array_filter($entity->get('roles')));
-    $entity->set('fields', array_filter($entity->get('fields')));
+    $types = [];
+    foreach (array_filter($form_state->getValue('enabled_recipient_types')) as $type) {
+      $types[$type] = [
+        'status' => TRUE,
+        'settings' => $form_state->getValue([
+          'recipient_types',
+          $type,
+          'settings',
+        ]),
+      ];
+    }
+    $entity->set('recipient_types', $types);
     $entity->set('bundles', array_filter($entity->get('bundles')));
   }
 
diff --git a/src/Plugin/QueueWorker/WorkbenchEmailProcessor.php b/src/Plugin/QueueWorker/WorkbenchEmailProcessor.php
index d9e4a0d..e081e40 100644
--- a/src/Plugin/QueueWorker/WorkbenchEmailProcessor.php
+++ b/src/Plugin/QueueWorker/WorkbenchEmailProcessor.php
@@ -84,8 +84,8 @@ class WorkbenchEmailProcessor extends QueueWorkerBase implements ContainerFactor
    *   Token service.
    * @param \Drupal\Core\Render\RendererInterface $renderer
    *   Renderer service.
-   * @param \Drupal\workbench_moderation\ModerationInformationInterface $renderer
-   *   Renderer service.
+   * @param \Drupal\workbench_moderation\ModerationInformationInterface $moderation_information
+   *   Moderation information.
    */
   public function __construct(array $configuration, $plugin_id, $plugin_definition, MailManagerInterface $mail_manager, EntityRepositoryInterface $entity_repository, Token $token, RendererInterface $renderer, ModerationInformationInterface $moderation_information) {
     parent::__construct($configuration, $plugin_id, $plugin_definition);
diff --git a/src/Plugin/RecipientType/Author.php b/src/Plugin/RecipientType/Author.php
new file mode 100644
index 0000000..b77ce24
--- /dev/null
+++ b/src/Plugin/RecipientType/Author.php
@@ -0,0 +1,34 @@
+<?php
+
+namespace Drupal\workbench_email\Plugin\RecipientType;
+
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\user\EntityOwnerInterface;
+use Drupal\workbench_email\Plugin\RecipientTypeBase;
+use Drupal\workbench_email\TemplateInterface;
+
+/**
+ * Provides a recipient type of the content author.
+ *
+ * @RecipientType(
+ *   id = "author",
+ *   title = @Translation("Author"),
+ *   description = @Translation("Send to entity author/owner."),
+ * )
+ */
+class Author extends RecipientTypeBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRecipients(ContentEntityInterface $entity, TemplateInterface $template) {
+    $recipients = [];
+    if ($this->isEnabled() && $entity instanceof EntityOwnerInterface) {
+      if (!$entity->getOwner()->isAnonymous()) {
+        $recipients[] = $entity->getOwner()->getEmail();
+      }
+    }
+    return $recipients;
+  }
+
+}
diff --git a/src/Plugin/RecipientType/EmailField.php b/src/Plugin/RecipientType/EmailField.php
new file mode 100644
index 0000000..0793f4e
--- /dev/null
+++ b/src/Plugin/RecipientType/EmailField.php
@@ -0,0 +1,223 @@
+<?php
+
+namespace Drupal\workbench_email\Plugin\RecipientType;
+
+use Drupal\Component\Utility\NestedArray;
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\Core\Entity\EntityFieldManagerInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Field\FieldItemInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\field\FieldStorageConfigInterface;
+use Drupal\workbench_email\Plugin\RecipientTypeBase;
+use Drupal\workbench_email\TemplateInterface;
+use Drupal\workbench_moderation\ModerationInformationInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Provides a recipient type of an email field.
+ *
+ * @RecipientType(
+ *   id = "email",
+ *   title = @Translation("Email field"),
+ *   description = @Translation("Send to email addresses in email field."),
+ *   settings = {
+ *     "fields" = {},
+ *   },
+ * )
+ */
+class EmailField extends RecipientTypeBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * The entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * The entity field manager.
+   *
+   * @var \Drupal\Core\Entity\EntityFieldManagerInterface
+   */
+  protected $entityFieldManager;
+
+  /**
+   * Moderation info service.
+   *
+   * @var \Drupal\workbench_moderation\ModerationInformationInterface
+   */
+  protected $moderationInfo;
+
+  /**
+   * Constructs a new EmailField object.
+   *
+   * @param array $configuration
+   *   Plugin configuration.
+   * @param string $plugin_id
+   *   The plugin ID.
+   * @param mixed $plugin_definition
+   *   The plugin definition.
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   *   The entity type manager.
+   * @param \Drupal\Core\Entity\EntityFieldManagerInterface $entity_field_manager
+   *   The entity field manager.
+   * @param \Drupal\workbench_moderation\ModerationInformationInterface $moderation_info
+   *   Moderation info service.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityTypeManagerInterface $entity_type_manager, EntityFieldManagerInterface $entity_field_manager, ModerationInformationInterface $moderation_info) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->entityTypeManager = $entity_type_manager;
+    $this->entityFieldManager = $entity_field_manager;
+    $this->moderationInfo = $moderation_info;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity_type.manager'),
+      $container->get('entity_field.manager'),
+      $container->get('workbench_moderation.moderation_information')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
+    // Add the fields.
+    $fields = $this->entityFieldManager->getFieldMapByFieldType('email');
+    $field_options = [];
+    foreach ($fields as $entity_type_id => $entity_type_fields) {
+      $entity_type = $this->entityTypeManager->getDefinition($entity_type_id);
+      if (!$this->moderationInfo->isModeratableEntityType($entity_type)) {
+        // These fields are irrelevant, the entity type isn't moderated.
+        continue;
+      }
+      $base = $this->entityFieldManager->getBaseFieldDefinitions($entity_type_id);
+      foreach ($entity_type_fields as $field_name => $field_detail) {
+        if (in_array($field_name, array_keys($base), TRUE)) {
+          continue;
+        }
+        $sample_bundle = reset($field_detail['bundles']);
+        $sample_field = $this->entityTypeManager->getStorage('field_config')
+          ->load($entity_type_id . '.' . $sample_bundle . '.' . $field_name);
+        $field_options[$entity_type_id . ':' . $field_name] = $sample_field->label() . ' (' . $entity_type->getLabel() . ')';
+      }
+    }
+    return [
+      'fields' => [
+        '#type' => 'checkboxes',
+        '#title' => $this->t('Email Fields'),
+        '#description' => $this->t('Send to mail address found in the selected fields'),
+        '#options' => $field_options,
+        '#default_value' => $this->getFields(),
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitConfigurationForm(array &$form, FormStateInterface $form_state) {
+    $this->setFields(array_values(array_filter($form_state->getValue('fields'))));
+    parent::submitConfigurationForm($form, $form_state);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRecipients(ContentEntityInterface $entity, TemplateInterface $template) {
+    $recipients = [];
+    $fields = array_filter($this->getFields(), function ($field_name) use ($entity) {
+      list($entity_type, $field_name) = explode(':', $field_name, 2);
+      return $entity_type === $entity->getEntityTypeId() && $entity->hasField($field_name) && !$entity->{$field_name}->isEmpty();
+    });
+    foreach ($fields as $field) {
+      list(, $field_name) = explode(':', $field, 2);
+      /** @var \Drupal\Core\Field\FieldItemInterface $field_item */
+      foreach ($entity->{$field_name} as $field_item) {
+        $recipients[] = $this->getEmailFromFieldItem($field_item);
+      }
+    }
+    return $recipients;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    $dependencies = [];
+    $field_storage = $this->entityTypeManager->getStorage('field_storage_config');
+    foreach ($this->getFields() as $identifier) {
+      list ($entity_type_id, $field_name) = explode(':', $identifier, 2);
+      if ($field = $field_storage->load("$entity_type_id.$field_name")) {
+        $dependencies[$field->getConfigDependencyKey()][] = $field->getConfigDependencyName();
+      }
+    }
+    return NestedArray::mergeDeep($dependencies, parent::calculateDependencies());
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function onDependencyRemoval(array $dependencies) {
+    $removed_fields = array_reduce($dependencies['config'], function (array $carry, $item) {
+      if (!$item instanceof FieldStorageConfigInterface) {
+        return $carry;
+      }
+      $carry[] = sprintf('%s:%s', $item->getTargetEntityTypeId(), $item->getName());
+      return $carry;
+    }, []);
+    if ($removed_fields && array_intersect($removed_fields, $this->getFields())) {
+      $this->setFields(array_diff($this->getFields(), $removed_fields));
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+  /**
+   * Gets value of roles.
+   *
+   * @return array
+   *   Value of roles
+   */
+  protected function getFields() {
+    return $this->getConfiguration()['settings']['fields'];
+  }
+
+  /**
+   * Sets roles.
+   *
+   * @param array $fields
+   *   Field IDs in {entity_type}:{field_name} format.
+   *
+   * @return $this
+   */
+  protected function setFields(array $fields) {
+    $configuration = $this->getConfiguration();
+    $configuration['settings']['fields'] = $fields;
+    $this->setConfiguration($configuration);
+    return $this;
+  }
+
+  /**
+   * Get field value.
+   *
+   * @param \Drupal\Core\Field\FieldItemInterface $field_item
+   *   Field item.
+   *
+   * @return string
+   *   Email.
+   */
+  protected function getEmailFromFieldItem(FieldItemInterface $field_item) {
+    return $field_item->get('value')->getValue();
+  }
+
+}
diff --git a/src/Plugin/RecipientType/EntityReferenceUser.php b/src/Plugin/RecipientType/EntityReferenceUser.php
new file mode 100644
index 0000000..e533d88
--- /dev/null
+++ b/src/Plugin/RecipientType/EntityReferenceUser.php
@@ -0,0 +1,71 @@
+<?php
+
+namespace Drupal\workbench_email\Plugin\RecipientType;
+
+use Drupal\Core\Field\FieldItemInterface;
+use Drupal\Core\Form\FormStateInterface;
+
+/**
+ * Provides a recipient type based on entity reference fields.
+ *
+ * @RecipientType(
+ *   id = "entity_reference_user",
+ *   title = @Translation("Entity Reference: User"),
+ *   description = @Translation("Send to users referenced in an entity reference field."),
+ *   settings = {
+ *     "fields" = {},
+ *   },
+ * )
+ */
+class EntityReferenceUser extends EmailField {
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
+    // Add the fields.
+    $fields = $this->entityFieldManager->getFieldMapByFieldType('entity_reference');
+    $field_options = [];
+    foreach ($fields as $entity_type_id => $entity_type_fields) {
+      $entity_type = $this->entityTypeManager->getDefinition($entity_type_id);
+      if (!$this->moderationInfo->isModeratableEntityType($entity_type)) {
+        // These fields are irrelevant, the entity type isn't moderated.
+        continue;
+      }
+      $base = $this->entityFieldManager->getBaseFieldDefinitions($entity_type_id);
+      foreach ($entity_type_fields as $field_name => $field_detail) {
+        if (in_array($field_name, array_keys($base), TRUE)) {
+          if ($base[$field_name]->getSetting('target_type') !== 'user') {
+            continue;
+          }
+          $field_options[$entity_type_id . ':' . $field_name] = $base[$field_name]->getLabel() . ' (' . $entity_type->getLabel() . ')';
+          continue;
+        }
+        $sample_bundle = reset($field_detail['bundles']);
+        $fields = $this->entityFieldManager->getFieldDefinitions($entity_type_id, $sample_bundle);
+        $sample_field = $fields[$field_name];
+        if ($sample_field->getSetting('target_type') !== 'user') {
+          continue;
+        }
+        $field_options[$entity_type_id . ':' . $field_name] = $sample_field->label() . ' (' . $entity_type->getLabel() . ')';
+      }
+    }
+    return [
+      'fields' => [
+        '#type' => 'checkboxes',
+        '#title' => $this->t('Entity Reference User Fields'),
+        '#description' => $this->t('Send to users referenced by the selected fields.'),
+        '#options' => $field_options,
+        '#default_value' => $this->getFields(),
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function getEmailFromFieldItem(FieldItemInterface $field_item) {
+    return $field_item->entity->getEmail();
+  }
+
+}
diff --git a/src/Plugin/RecipientType/Role.php b/src/Plugin/RecipientType/Role.php
new file mode 100644
index 0000000..d626a08
--- /dev/null
+++ b/src/Plugin/RecipientType/Role.php
@@ -0,0 +1,169 @@
+<?php
+
+namespace Drupal\workbench_email\Plugin\RecipientType;
+
+use Drupal\Component\Utility\NestedArray;
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\Core\Entity\EntityTypeManagerInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Plugin\ContainerFactoryPluginInterface;
+use Drupal\user\RoleInterface;
+use Drupal\workbench_email\Plugin\RecipientTypeBase;
+use Drupal\workbench_email\TemplateInterface;
+use Symfony\Component\DependencyInjection\ContainerInterface;
+
+/**
+ * Provides a recipient type of user role.
+ *
+ * @RecipientType(
+ *   id = "role",
+ *   title = @Translation("Role"),
+ *   description = @Translation("Send to all users with selected roles."),
+ *   settings = {
+ *     "roles" = {},
+ *   },
+ * )
+ */
+class Role extends RecipientTypeBase implements ContainerFactoryPluginInterface {
+
+  /**
+   * The entity type manager.
+   *
+   * @var \Drupal\Core\Entity\EntityTypeManagerInterface
+   */
+  protected $entityTypeManager;
+
+  /**
+   * Constructs a new Role object.
+   *
+   * @param array $configuration
+   *   Plugin configuration.
+   * @param string $plugin_id
+   *   The plugin ID.
+   * @param mixed $plugin_definition
+   *   The plugin definition.
+   * @param \Drupal\Core\Entity\EntityTypeManagerInterface $entity_type_manager
+   *   The entity type manager.
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition, EntityTypeManagerInterface $entity_type_manager) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+    $this->entityTypeManager = $entity_type_manager;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
+    return new static(
+      $configuration,
+      $plugin_id,
+      $plugin_definition,
+      $container->get('entity_type.manager')
+    );
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
+    $roles = array_filter($this->entityTypeManager->getStorage('user_role')
+      ->loadMultiple(), function (RoleInterface $role) {
+        return !in_array($role->id(), [
+          RoleInterface::ANONYMOUS_ID,
+          RoleInterface::AUTHENTICATED_ID,
+        ], TRUE);
+      });
+    $role_options = array_map(function (RoleInterface $role) {
+      return $role->label();
+    }, $roles);
+    return [
+      'roles' => [
+        '#type' => 'checkboxes',
+        '#title' => $this->t('Roles'),
+        '#description' => $this->t('Send to all users with selected roles'),
+        '#options' => $role_options,
+        '#default_value' => $this->getRoles(),
+      ],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitConfigurationForm(array &$form, FormStateInterface $form_state) {
+    $this->setRoles(array_filter($form_state->getValue('roles')));
+    parent::submitConfigurationForm($form, $form_state);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRecipients(ContentEntityInterface $entity, TemplateInterface $template) {
+    $recipients = [];
+    foreach ($this->getRoles() as $role) {
+      foreach ($this->entityTypeManager->getStorage('user')->loadByProperties([
+        'roles' => $role,
+        'status' => 1,
+      ]) as $account) {
+        $recipients[] = $account->getEmail();
+      }
+    }
+    return $recipients;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    $dependencies = [];
+    $role_storage = $this->entityTypeManager->getStorage('user_role');
+    foreach ($role_storage->loadMultiple($this->getRoles()) as $role) {
+      $dependencies[$role->getConfigDependencyKey()][] = $role->getConfigDependencyName();
+    }
+    return NestedArray::mergeDeep($dependencies, parent::calculateDependencies());
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function onDependencyRemoval(array $dependencies) {
+    $removed_roles = array_reduce($dependencies['config'], function (array $carry, $item) {
+      if (!$item instanceof RoleInterface) {
+        return $carry;
+      }
+      $carry[] = $item->id();
+      return $carry;
+    }, []);
+    if ($removed_roles && array_intersect($removed_roles, $this->getRoles())) {
+      $this->setRoles(array_diff($this->getRoles(), $removed_roles));
+      return TRUE;
+    }
+    return FALSE;
+  }
+
+  /**
+   * Gets value of roles.
+   *
+   * @return array
+   *   Value of roles
+   */
+  protected function getRoles() {
+    return $this->getConfiguration()['settings']['roles'];
+  }
+
+  /**
+   * Sets roles.
+   *
+   * @param array $roles
+   *   Role IDs.
+   *
+   * @return $this
+   */
+  protected function setRoles(array $roles) {
+    $configuration = $this->getConfiguration();
+    $configuration['settings']['roles'] = $roles;
+    $this->setConfiguration($configuration);
+    return $this;
+  }
+
+}
diff --git a/src/Plugin/RecipientTypeBase.php b/src/Plugin/RecipientTypeBase.php
new file mode 100644
index 0000000..33a5507
--- /dev/null
+++ b/src/Plugin/RecipientTypeBase.php
@@ -0,0 +1,154 @@
+<?php
+
+namespace Drupal\workbench_email\Plugin;
+
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\Core\Plugin\PluginBase;
+use Drupal\Core\Plugin\PluginWithFormsTrait;
+use Drupal\workbench_email\TemplateInterface;
+
+/**
+ * Provides a base class for Recipient type plugins.
+ *
+ * @see \Drupal\workbench_email\Annotation\RecipientType
+ * @see \Drupal\workbench_email\RecipientTypeManager
+ * @see \Drupal\workbench_email\Plugin\RecipientTypeInterface
+ * @see plugin_api
+ */
+abstract class RecipientTypeBase extends PluginBase implements RecipientTypeInterface {
+
+  use PluginWithFormsTrait;
+
+  /**
+   * The name of the provider that owns this recipient type.
+   *
+   * @var string
+   */
+  public $provider;
+
+  /**
+   * A Boolean indicating whether this recipient type is enabled.
+   *
+   * @var bool
+   */
+  public $status = FALSE;
+
+  /**
+   * An associative array containing the settings of this recipient type.
+   *
+   * @var array
+   */
+  public $settings = [];
+
+  /**
+   * {@inheritdoc}
+   */
+  public function __construct(array $configuration, $plugin_id, $plugin_definition) {
+    parent::__construct($configuration, $plugin_id, $plugin_definition);
+
+    $this->provider = $this->pluginDefinition['provider'];
+
+    $this->setConfiguration($configuration);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function setConfiguration(array $configuration) {
+    if (isset($configuration['status'])) {
+      $this->status = (bool) $configuration['status'];
+    }
+    if (isset($configuration['settings'])) {
+      $this->settings = (array) $configuration['settings'];
+    }
+    return $this;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getConfiguration() {
+    return [
+      'id' => $this->getPluginId(),
+      'provider' => $this->pluginDefinition['provider'],
+      'status' => $this->status,
+      'settings' => $this->settings,
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function defaultConfiguration() {
+    return [
+      'provider' => $this->pluginDefinition['provider'],
+      'status' => FALSE,
+      'settings' => $this->pluginDefinition['settings'],
+    ];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function calculateDependencies() {
+    return [];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getLabel() {
+    return $this->pluginDefinition['title'];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function getDescription() {
+    return $this->pluginDefinition['description'];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function buildConfigurationForm(array $form, FormStateInterface $form_state) {
+    return [];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function prepareRecipients(ContentEntityInterface $entity, TemplateInterface $template) {
+    return [];
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function validateConfigurationForm(array &$form, FormStateInterface $form_state) {
+    // Nil op.
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function submitConfigurationForm(array &$form, FormStateInterface $form_state) {
+    // Nil op.
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function isEnabled() {
+    return $this->status;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function onDependencyRemoval(array $dependencies) {
+    return FALSE;
+  }
+
+}
diff --git a/src/Plugin/RecipientTypeInterface.php b/src/Plugin/RecipientTypeInterface.php
new file mode 100644
index 0000000..b28a6eb
--- /dev/null
+++ b/src/Plugin/RecipientTypeInterface.php
@@ -0,0 +1,88 @@
+<?php
+
+namespace Drupal\workbench_email\Plugin;
+
+use Drupal\Component\Plugin\PluginInspectionInterface;
+use Drupal\Component\Plugin\ConfigurablePluginInterface;
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\Core\Form\FormStateInterface;
+use Drupal\workbench_email\TemplateInterface;
+use Drupal\Core\Plugin\PluginFormInterface;
+use Drupal\Core\Plugin\PluginWithFormsInterface;
+
+/**
+ * Defines the interface for Recipient type plugins.
+ *
+ * TODO Docs.
+ *
+ * @see \Drupal\workbench_email\Annotation\RecipientType
+ * @see \Drupal\workbench_email\RecipientTypePluginManager
+ * @see \Drupal\workbench_email\Plugin\RecipientTypeBase
+ * @see plugin_api
+ */
+interface RecipientTypeInterface extends ConfigurablePluginInterface, PluginInspectionInterface, PluginWithFormsInterface, PluginFormInterface {
+
+  /**
+   * Returns the administrative label for this recipient type plugin.
+   *
+   * @return string
+   *   The label.
+   */
+  public function getLabel();
+
+  /**
+   * Returns the administrative description for this recipient type plugin.
+   *
+   * @return string
+   *   The description.
+   */
+  public function getDescription();
+
+  /**
+   * Generates a recipient types's settings form.
+   *
+   * @param array $form
+   *   A minimally prepopulated form array.
+   * @param \Drupal\Core\Form\FormStateInterface $form_state
+   *   The state of the (entire) configuration form.
+   *
+   * @return array
+   *   The $form array with additional form elements for the settings of this
+   *   recipient type. The submitted form values should match $this->settings.
+   */
+  public function buildConfigurationForm(array $form, FormStateInterface $form_state);
+
+  /**
+   * Returns email address(s) matching this recipient type's configuration.
+   *
+   * @param \Drupal\Core\Entity\ContentEntityInterface $entity
+   *   Entity being transitioned.
+   * @param \Drupal\workbench_email\TemplateInterface $template
+   *   Template being used.
+   */
+  public function prepareRecipients(ContentEntityInterface $entity, TemplateInterface $template);
+
+  /**
+   * Checks status.
+   *
+   * @return bool
+   *   TRUE if enabled.
+   */
+  public function isEnabled();
+
+  /**
+   * Informs the plugin that a dependency of the recipient type will be deleted.
+   *
+   * @param array $dependencies
+   *   An array of dependencies that will be deleted keyed by dependency type.
+   *
+   * @return bool
+   *   TRUE if the template settings have been changed.
+   *
+   * @see \Drupal\Core\Config\ConfigEntityInterface::onDependencyRemoval()
+   *
+   * @todo https://www.drupal.org/node/2579743 make part of a generic interface.
+   */
+  public function onDependencyRemoval(array $dependencies);
+
+}
diff --git a/src/RecipientTypePluginCollection.php b/src/RecipientTypePluginCollection.php
new file mode 100644
index 0000000..6b282e1
--- /dev/null
+++ b/src/RecipientTypePluginCollection.php
@@ -0,0 +1,68 @@
+<?php
+
+namespace Drupal\workbench_email;
+
+use Drupal\Component\Utility\NestedArray;
+use Drupal\Core\Plugin\DefaultLazyPluginCollection;
+
+/**
+ * A collection of recipient types.
+ */
+class RecipientTypePluginCollection extends DefaultLazyPluginCollection {
+
+  /**
+   * All possible recipient type plugin IDs.
+   *
+   * @var array
+   */
+  protected $definitions;
+
+  /**
+   * {@inheritdoc}
+   *
+   * @return \Drupal\workbench_email\Plugin\RecipientTypeInterface
+   *   The recipient type.
+   */
+  public function &get($instance_id) {
+    return parent::get($instance_id);
+  }
+
+  /**
+   * Retrieves plugin definitions and creates an instance for each.
+   */
+  public function getAll() {
+    // Retrieve all available behavior plugin definitions.
+    if (!$this->definitions) {
+      $this->definitions = $this->manager->getDefinitions();
+    }
+    // Ensure that there is an instance of all available behavior plugins.
+    foreach ($this->definitions as $plugin_id => $definition) {
+      if (!isset($this->pluginInstances[$plugin_id])) {
+        $this->initializePlugin($plugin_id);
+      }
+    }
+    return $this->pluginInstances;
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function initializePlugin($instance_id) {
+    $configuration = $this->manager->getDefinition($instance_id);
+    // Merge the actual configuration into the default configuration.
+    if (isset($this->configurations[$instance_id])) {
+      $configuration = NestedArray::mergeDeep($configuration, $this->configurations[$instance_id]);
+    }
+    $this->configurations[$instance_id] = $configuration;
+    parent::initializePlugin($instance_id);
+  }
+
+  /**
+   * {@inheritdoc}
+   */
+  public function sort() {
+    $this->getAll();
+    return parent::sort();
+  }
+
+}
diff --git a/src/RecipientTypePluginManager.php b/src/RecipientTypePluginManager.php
new file mode 100644
index 0000000..c5212a2
--- /dev/null
+++ b/src/RecipientTypePluginManager.php
@@ -0,0 +1,37 @@
+<?php
+
+namespace Drupal\workbench_email;
+
+use Drupal\Core\Cache\CacheBackendInterface;
+use Drupal\Core\Extension\ModuleHandlerInterface;
+use Drupal\Core\Plugin\DefaultPluginManager;
+
+/**
+ * Manages recipient types.
+ *
+ * @see hook_recipient_type_info_alter()
+ * @see \Drupal\workbench_email\Annotation\RecipientType
+ * @see \Drupal\workbench_email\Plugin\RecipientTypeInterface
+ * @see \Drupal\workbench_email\Plugin\RecipientTypeBase
+ * @see plugin_api
+ */
+class RecipientTypePluginManager extends DefaultPluginManager {
+
+  /**
+   * Constructs a RecipientTypePluginManager object.
+   *
+   * @param \Traversable $namespaces
+   *   An object that implements \Traversable which contains the root paths
+   *   keyed by the corresponding namespace to look for plugin implementations.
+   * @param \Drupal\Core\Cache\CacheBackendInterface $cache_backend
+   *   Cache backend instance to use.
+   * @param \Drupal\Core\Extension\ModuleHandlerInterface $module_handler
+   *   The module handler to invoke the alter hook with.
+   */
+  public function __construct(\Traversable $namespaces, CacheBackendInterface $cache_backend, ModuleHandlerInterface $module_handler) {
+    parent::__construct('Plugin/RecipientType', $namespaces, $module_handler, 'Drupal\workbench_email\Plugin\RecipientTypeInterface', 'Drupal\workbench_email\Annotation\RecipientType');
+    $this->alterInfo('recipient_type_info');
+    $this->setCacheBackend($cache_backend, 'recipient_type_plugins');
+  }
+
+}
diff --git a/src/TemplateHtmlRouteProvider.php b/src/TemplateHtmlRouteProvider.php
index 4576586..aa67a16 100644
--- a/src/TemplateHtmlRouteProvider.php
+++ b/src/TemplateHtmlRouteProvider.php
@@ -13,6 +13,7 @@ use Symfony\Component\Routing\Route;
  * @see Drupal\Core\Entity\Routing\DefaultHtmlRouteProvider
  */
 class TemplateHtmlRouteProvider extends AdminHtmlRouteProvider {
+
   /**
    * {@inheritdoc}
    */
diff --git a/src/TemplateInterface.php b/src/TemplateInterface.php
index 0bece96..3b8ed00 100644
--- a/src/TemplateInterface.php
+++ b/src/TemplateInterface.php
@@ -3,11 +3,13 @@
 namespace Drupal\workbench_email;
 
 use Drupal\Core\Config\Entity\ConfigEntityInterface;
+use Drupal\Core\Entity\ContentEntityInterface;
+use Drupal\Core\Entity\EntityWithPluginCollectionInterface;
 
 /**
  * Provides an interface for defining Email Template entities.
  */
-interface TemplateInterface extends ConfigEntityInterface {
+interface TemplateInterface extends ConfigEntityInterface, EntityWithPluginCollectionInterface {
 
   /**
    * Gets the template subject.
@@ -48,61 +50,16 @@ interface TemplateInterface extends ConfigEntityInterface {
   public function setSubject($subject);
 
   /**
-   * Gets value of author.
+   * Returns collection of recipient type plugin instances or a plugin instance.
    *
-   * @return boolean
-   *   Value of author
-   */
-  public function isAuthor();
-
-  /**
-   * Sets author.
-   *
-   * @param boolean $author
-   *   New value for author.
-   *
-   * @return self
-   *   Instance called.
-   */
-  public function setAuthor($author);
-
-  /**
-   * Gets value of fields.
-   *
-   * @return string[]
-   *   Value of fields
-   */
-  public function getFields();
-
-  /**
-   * Sets fields.
-   *
-   * @param string[] $fields
-   *   New value for fields.
-   *
-   * @return self
-   *   Instance called.
-   */
-  public function setFields(array $fields);
-
-  /**
-   * Gets value of roles.
-   *
-   * @return string[]
-   *   Value of roles
-   */
-  public function getRoles();
-
-  /**
-   * Sets roles.
-   *
-   * @param string[] $roles
-   *   New value for roles.
+   * @param string $instance_id
+   *   (optional) The ID of a recipient type plugin instance to return.
    *
-   * @return self
-   *   Instance called.
+   * @return \Drupal\workbench_email\RecipientTypePluginCollection|\Drupal\workbench_email\Plugin\RecipientTypeInterface
+   *   Either the recipient type collection or a specific recipient type plugin
+   *   instance.
    */
-  public function setRoles(array $roles);
+  public function recipientTypes($instance_id = NULL);
 
   /**
    * Gets value of bundles.
@@ -121,6 +78,17 @@ interface TemplateInterface extends ConfigEntityInterface {
    * @return self
    *   Called instance.
    */
-  public function setBundles($bundles);
+  public function setBundles(array $bundles);
+
+  /**
+   * Calculates recipients.
+   *
+   * @param \Drupal\Core\Entity\ContentEntityInterface $entity
+   *   Entity being sent.
+   *
+   * @return array
+   *   Array of email addresses.
+   */
+  public function getRecipients(ContentEntityInterface $entity);
 
 }
diff --git a/src/TemplateListBuilder.php b/src/TemplateListBuilder.php
index 70f09f6..7d587e5 100644
--- a/src/TemplateListBuilder.php
+++ b/src/TemplateListBuilder.php
@@ -9,6 +9,7 @@ use Drupal\Core\Entity\EntityInterface;
  * Provides a listing of Email Template entities.
  */
 class TemplateListBuilder extends ConfigEntityListBuilder {
+
   /**
    * {@inheritdoc}
    */
diff --git a/tests/fixtures/update/recipient-plugins.php.gz b/tests/fixtures/update/recipient-plugins.php.gz
new file mode 100644
index 0000000000000000000000000000000000000000..694e2c3fd817d672dd050561c960f9288eff0d73
GIT binary patch
literal 81873
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
AH2?qr

literal 0
HcmV?d00001

diff --git a/tests/src/Functional/RecipientPluginUpdatePathTest.php b/tests/src/Functional/RecipientPluginUpdatePathTest.php
new file mode 100644
index 0000000..007b640
--- /dev/null
+++ b/tests/src/Functional/RecipientPluginUpdatePathTest.php
@@ -0,0 +1,49 @@
+<?php
+
+namespace Drupal\Tests\workbench_email\Functional;
+
+use Drupal\FunctionalTests\Update\UpdatePathTestBase;
+
+/**
+ * Defines a class for testing upgrade path.
+ *
+ * @group workbench_email
+ */
+class RecipientPluginUpdatePathTest extends UpdatePathTestBase {
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setDatabaseDumpFiles() {
+    $this->databaseDumpFiles = [
+      __DIR__ . '/../../fixtures/update/recipient-plugins.php.gz',
+    ];
+  }
+
+  /**
+   * Tests workbench_email_update_8001().
+   */
+  public function testUpdatePath() {
+    $this->runUpdates();
+    $entity_type_manager = $this->container->get('entity_type.manager');
+    /** @var \Drupal\workbench_email\TemplateInterface $template */
+    $template = $entity_type_manager->getStorage('workbench_email_template')->load('send');
+    $nodes = $entity_type_manager->getStorage('node')->loadByProperties([
+      'title' => 'test node',
+    ]);
+    $recipients = $template->getRecipients(reset($nodes));
+    $expected = [
+      // User with approver role.
+      'bob@example.com',
+      // Author.
+      'admin@example.com',
+      // Email field on node.
+      'terri@example.com',
+    ];
+    $this->assertEquals(sort($expected), sort($recipients));
+    $this->assertNull($template->get('author'));
+    $this->assertNull($template->get('fields'));
+    $this->assertNull($template->get('roles'));
+  }
+
+}
diff --git a/tests/src/Functional/WorkbenchTransitionEmailTest.php b/tests/src/Functional/WorkbenchTransitionEmailTest.php
index 48cc739..1e5c7ee 100644
--- a/tests/src/Functional/WorkbenchTransitionEmailTest.php
+++ b/tests/src/Functional/WorkbenchTransitionEmailTest.php
@@ -2,34 +2,27 @@
 
 namespace Drupal\Tests\workbench_email\Functional;
 
-use Drupal\Core\Entity\Entity\EntityFormDisplay;
 use Drupal\Core\Test\AssertMailTrait;
 use Drupal\Core\Url;
-use Drupal\field\Entity\FieldConfig;
-use Drupal\field\Entity\FieldStorageConfig;
 use Drupal\node\Entity\NodeType;
-use Drupal\node\NodeTypeInterface;
-use Drupal\simpletest\BlockCreationTrait;
-use Drupal\simpletest\NodeCreationTrait;
+use Drupal\Tests\block\Traits\BlockCreationTrait;
 use Drupal\Tests\BrowserTestBase;
+use Drupal\Tests\node\Traits\NodeCreationTrait;
+use Drupal\Tests\workbench_email\Traits\WorkbenchEmailTestTrait;
 use Drupal\workbench_email\Entity\Template;
-use Drupal\workbench_moderation\Entity\ModerationState;
 use Drupal\workbench_moderation\Entity\ModerationStateTransition;
 
 /**
  * Tests the view access control handler for moderation state entities.
  *
- * @group workbench_moderation
- *
- * @runTestsInSeparateProcesses
- *
- * @preserveGlobalState disabled
+ * @group workbench_email
  */
 class WorkbenchTransitionEmailTest extends BrowserTestBase {
 
   use AssertMailTrait;
   use BlockCreationTrait;
   use NodeCreationTrait;
+  use WorkbenchEmailTestTrait;
 
   /**
    * Test node type.
@@ -123,12 +116,12 @@ class WorkbenchTransitionEmailTest extends BrowserTestBase {
       'type' => 'test',
       'name' => 'Test',
     ]);
-    $this->setupModerationForNodeType($this->nodeType);
+    $this->setUpModerationForNodeType($this->nodeType);
     $this->nodeType = NodeType::create([
       'type' => 'another',
       'name' => 'Another Test',
     ]);
-    $this->setupModerationForNodeType($this->nodeType);
+    $this->setUpModerationForNodeType($this->nodeType);
     // Create an approver role and two users.
     $this->approverRole = $this->drupalCreateRole([
       'view any unpublished content',
@@ -179,28 +172,8 @@ class WorkbenchTransitionEmailTest extends BrowserTestBase {
       'administer workbench_email templates',
       'access administration pages',
     ]);
-    // Add an email field notify to the node-type.
-    FieldStorageConfig::create([
-      'cardinality' => 1,
-      'entity_type' => 'node',
-      'field_name' => 'field_email',
-      'type' => 'email',
-    ])->save();
-    FieldConfig::create([
-      'field_name' => 'field_email',
-      'bundle' => 'test',
-      'label' => 'Notify',
-      'entity_type' => 'node',
-    ])->save();
-    if (!$entity_form_display = EntityFormDisplay::load('node.test.default')) {
-      $entity_form_display = EntityFormDisplay::create([
-        'targetEntityType' => 'node',
-        'bundle' => 'test',
-        'mode' => 'default',
-        'status' => TRUE,
-      ]);
-    }
-    $entity_form_display->setComponent('field_email', ['type' => 'email_default'])->save();
+    // Add an email field notify to the test bundle.
+    $this->setUpEmailFieldForNodeBundle();
   }
 
   /**
@@ -236,8 +209,11 @@ class WorkbenchTransitionEmailTest extends BrowserTestBase {
       'label' => 'Content approved',
       'body[value]' => 'Content with title [node:title] was approved. You can view it at [node:url].',
       'subject' => 'Content approved: [node:title]',
-      'fields[node:field_email]' => TRUE,
-      'author' => TRUE,
+      'enabled_recipient_types[author]' => TRUE,
+      'enabled_recipient_types[email]' => TRUE,
+      'enabled_recipient_types[role]' => TRUE,
+      'recipient_types[email][settings][fields][node:field_email]' => TRUE,
+      'recipient_types[role][settings][roles][editor]' => TRUE,
     ], t('Save'));
     $assert->pageTextContains('Created the Content approved Email Template');
     $page->clickLink('Add Email Template');
@@ -247,7 +223,8 @@ class WorkbenchTransitionEmailTest extends BrowserTestBase {
       'label' => 'Content needs review',
       'body[value]' => 'Content with title [node:title] needs review. You can view it at [node:url].',
       'subject' => 'Content needs review',
-      'roles[approver]' => TRUE,
+      'enabled_recipient_types[role]' => TRUE,
+      'recipient_types[role][settings][roles][approver]' => TRUE,
       'bundles[node:test]' => TRUE,
     ], t('Save'));
     $assert->pageTextContains('Created the Content needs review Email Template');
@@ -314,8 +291,8 @@ class WorkbenchTransitionEmailTest extends BrowserTestBase {
     $this->assertTrue($last && isset($last['to']) && $last['to'] == $this->approver2->mail->value);
     $this->assertEquals(sprintf('Content needs review: %s', $node->getTitle()), $last['subject']);
     $this->assertEquals(sprintf('Content needs review: %s', $node->getTitle()), $prev['subject']);
-    $this->assertContains(sprintf('Content with title %s needs review. You can view it at %s', $node->label(), $node->toUrl('canonical', ['absolute' => TRUE])->toString()), preg_replace('/\s+/', ' ', $prev['body']));
-    $this->assertContains(sprintf('Content with title %s needs review. You can view it at %s', $node->label(), $node->toUrl('canonical', ['absolute' => TRUE])->toString()), preg_replace('/\s+/', ' ', $last['body']));
+    $this->assertContains(sprintf('Content with title %s needs review. You can view it at', $node->label()), preg_replace('/\s+/', ' ', $prev['body']));
+    $this->assertContains(sprintf('Content with title %s needs review. You can view it at', $node->label()), preg_replace('/\s+/', ' ', $last['body']));
 
     // Now try again going straight to needs review (no draft).
     // Reset collected email.
@@ -336,8 +313,8 @@ class WorkbenchTransitionEmailTest extends BrowserTestBase {
     $this->assertTrue($last && isset($last['to']) && $last['to'] == $this->approver2->mail->value);
     $this->assertEquals(sprintf('Content needs review: %s', $node2->getTitle()), $last['subject']);
     $this->assertEquals(sprintf('Content needs review: %s', $node2->getTitle()), $prev['subject']);
-    $this->assertContains(sprintf('Content with title %s needs review. You can view it at %s', $node2->label(), $node2->toUrl('canonical', ['absolute' => TRUE])->toString()), preg_replace('/\s+/', ' ', $prev['body']));
-    $this->assertContains(sprintf('Content with title %s needs review. You can view it at %s', $node2->label(), $node2->toUrl('canonical', ['absolute' => TRUE])->toString()), preg_replace('/\s+/', ' ', $last['body']));
+    $this->assertContains(sprintf('Content with title %s needs review. You can view it at', $node2->label()), preg_replace('/\s+/', ' ', $prev['body']));
+    $this->assertContains(sprintf('Content with title %s needs review. You can view it at', $node2->label()), preg_replace('/\s+/', ' ', $last['body']));
 
     // Login as approver and transition to approved.
     $this->drupalLogin($this->approver1);
@@ -351,8 +328,8 @@ class WorkbenchTransitionEmailTest extends BrowserTestBase {
     $this->assertTrue($last && isset($last['to']) && $last['to'] == 'foo@example.com');
     $this->assertEquals(sprintf('Content approved: %s', $node->getTitle()), $last['subject']);
     $this->assertEquals(sprintf('Content approved: %s', $node->getTitle()), $prev['subject']);
-    $this->assertContains(sprintf('Content with title %s was approved. You can view it at %s', $node->label(), $node->toUrl('canonical', ['absolute' => TRUE])->toString()), preg_replace('/\s+/', ' ', $prev['body']));
-    $this->assertContains(sprintf('Content with title %s was approved. You can view it at %s', $node->label(), $node->toUrl('canonical', ['absolute' => TRUE])->toString()), preg_replace('/\s+/', ' ', $last['body']));
+    $this->assertContains(sprintf('Content with title %s was approved. You can view it at', $node->label()), preg_replace('/\s+/', ' ', $prev['body']));
+    $this->assertContains(sprintf('Content with title %s was approved. You can view it at', $node->label()), preg_replace('/\s+/', ' ', $last['body']));
     // Try with the other node type, that isn't enabled.
     // Log back in as editor.
     $this->drupalLogin($this->editor);
@@ -371,19 +348,4 @@ class WorkbenchTransitionEmailTest extends BrowserTestBase {
     $this->assertEmpty($captured_emails);
   }
 
-  /**
-   * Enables moderation for a given node type.
-   *
-   * @param \Drupal\node\NodeTypeInterface $node_type
-   *   Node type to enable moderation for.
-   */
-  protected function setupModerationForNodeType(NodeTypeInterface $node_type) {
-    $node_type->setThirdPartySetting('workbench_moderation', 'enabled', TRUE);
-    $states = array_keys(ModerationState::loadMultiple());
-    $node_type->setThirdPartySetting('workbench_moderation', 'allowed_moderation_states', $states);
-    $node_type->setThirdPartySetting('workbench_moderation', 'default_moderation_state', 'draft');
-    $node_type->save();
-  }
-
 }
-
diff --git a/tests/src/Kernel/ConfigDependenciesTest.php b/tests/src/Kernel/ConfigDependenciesTest.php
new file mode 100644
index 0000000..5caed56
--- /dev/null
+++ b/tests/src/Kernel/ConfigDependenciesTest.php
@@ -0,0 +1,158 @@
+<?php
+
+namespace Drupal\Tests\workbench_email\Kernel;
+
+use Drupal\field\Entity\FieldConfig;
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\user\Entity\Role;
+use Drupal\Tests\node\Traits\ContentTypeCreationTrait;
+use Drupal\Tests\workbench_email\Traits\WorkbenchEmailTestTrait;
+use Drupal\workbench_email\Entity\Template;
+
+/**
+ * Defines a class for testing config dependencies.
+ *
+ * @group workbench_email
+ */
+class ConfigDependenciesTest extends KernelTestBase {
+
+  use ContentTypeCreationTrait;
+  use WorkbenchEmailTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'node',
+    'text',
+    'system',
+    'user',
+    'workbench_email',
+    'workbench_moderation',
+    'field',
+  ];
+
+  /**
+   * The template being tested.
+   *
+   * @var \Drupal\workbench_email\TemplateInterface
+   */
+  protected $template;
+
+  /**
+   * The editor role.
+   *
+   * @var \Drupal\user\Entity\Role
+   */
+  protected $editorRole;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    $this->installEntitySchema('node');
+    $this->installConfig([
+      'node',
+      'workbench_moderation',
+      'workbench_email',
+      'system',
+    ]);
+    $this->installEntitySchema('user');
+    $this->installSchema('system', ['key_value', 'sequences']);
+    $node_type = $this->createContentType(['type' => 'test']);
+    $this->setUpModerationForNodeType($node_type);
+    $this->setUpEmailFieldForNodeBundle();
+    $this->editorRole = Role::create(['id' => 'editor']);
+    $this->editorRole->save();
+    $this->template = $this->setUpTemplate();
+  }
+
+  /**
+   * Tests scheme dependencies.
+   */
+  public function testSchemeDependencies() {
+    $this->assertEquals([
+      'config' => [
+        'field.storage.node.field_email',
+        'user.role.editor',
+      ],
+    ], $this->template->getDependencies());
+
+    // Delete the editor role.
+    $this->editorRole->delete();
+    $this->template = $this->loadUnchangedTemplate($this->template->id());
+    $this->assertEquals([
+      'config' => [
+        'field.storage.node.field_email',
+      ],
+    ], $this->template->getDependencies());
+
+    // Delete the email field.
+    FieldConfig::load('node.test.field_email')->delete();
+    $this->template = $this->loadUnchangedTemplate($this->template->id());
+    $this->assertEquals([], $this->template->getDependencies());
+  }
+
+  /**
+   * Creates a test email template.
+   *
+   * @param string $id
+   *   The id for the template.
+   *
+   * @return \Drupal\workbench_email\Entity\Template
+   *   Created template.
+   */
+  protected function setUpTemplate($id = 'test_template') {
+    $template = Template::create([
+      'id' => $id,
+      'label' => ucfirst(str_replace('_', ' ', $id)),
+      'recipient_types' => [
+        'role' => [
+          'id' => 'role',
+          'provider' => 'workbench_email',
+          'status' => 1,
+          'settings' => [
+            'roles' => [
+              'editor' => 'editor',
+            ],
+          ],
+        ],
+        'author' => [
+          'id' => 'author',
+          'provider' => 'workbench_email',
+          'status' => 1,
+          'settings' => [],
+        ],
+        'email' => [
+          'id' => 'email',
+          'provider' => 'workbench_email',
+          'status' => 1,
+          'settings' => [
+            'fields' => [
+              'node:field_email',
+            ],
+          ],
+        ],
+      ],
+    ]);
+    $template->save();
+    return $template;
+  }
+
+  /**
+   * Loads the given template.
+   *
+   * @param string $template_id
+   *   Template ID.
+   *
+   * @return \Drupal\workbench_email\TemplateInterface
+   *   Unchanged scheme.
+   */
+  protected function loadUnchangedTemplate($template_id) {
+    return $this->container->get('entity_type.manager')
+      ->getStorage('workbench_email_template')
+      ->loadUnchanged($template_id);
+  }
+
+}
diff --git a/tests/src/Kernel/RecipientTypePluginsTest.php b/tests/src/Kernel/RecipientTypePluginsTest.php
new file mode 100644
index 0000000..4872e08
--- /dev/null
+++ b/tests/src/Kernel/RecipientTypePluginsTest.php
@@ -0,0 +1,204 @@
+<?php
+
+namespace Drupal\Tests\workbench_email\Kernel;
+
+use Drupal\field\Tests\EntityReference\EntityReferenceTestTrait;
+use Drupal\KernelTests\KernelTestBase;
+use Drupal\node\Entity\Node;
+use Drupal\Tests\node\Traits\ContentTypeCreationTrait;
+use Drupal\Tests\user\Traits\UserCreationTrait;
+use Drupal\Tests\workbench_email\Traits\WorkbenchEmailTestTrait;
+use Drupal\user\Entity\Role;
+use Drupal\workbench_email\Entity\Template;
+use Drupal\workbench_moderation\Entity\ModerationStateTransition;
+
+/**
+ * Defines a class for testing handlers.
+ *
+ * @group workbench_email
+ */
+class RecipientTypePluginsTest extends KernelTestBase {
+
+  use WorkbenchEmailTestTrait;
+  use ContentTypeCreationTrait;
+  use UserCreationTrait;
+  use EntityReferenceTestTrait;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected static $modules = [
+    'node',
+    'text',
+    'filter',
+    'system',
+    'user',
+    'workbench_email',
+    'workbench_moderation',
+    'field',
+  ];
+
+  /**
+   * Author.
+   *
+   * @var \Drupal\user\UserInterface
+   */
+  protected $author;
+
+  /**
+   * Approver.
+   *
+   * @var \Drupal\user\UserInterface
+   */
+  protected $approver;
+
+  /**
+   * {@inheritdoc}
+   */
+  protected function setUp() {
+    parent::setUp();
+    parent::setUp();
+    $this->installEntitySchema('node');
+    $this->installConfig([
+      'node',
+      'workbench_moderation',
+      'workbench_email',
+      'system',
+      'filter',
+    ]);
+    $this->installEntitySchema('user');
+    $this->installSchema('system', ['key_value', 'sequences']);
+    $this->installSchema('node', ['node_access']);
+    $node_type = $this->createContentType(['type' => 'test']);
+
+    $this->setUpModerationForNodeType($node_type);
+    $this->setUpEmailFieldForNodeBundle();
+    $this->createEntityReferenceField('node', 'test', 'field_approver', 'Approver', 'user');
+    Role::create(['id' => 'editor'])->save();
+    $editor = $this->createUser(['use draft_needs_review transition']);
+    $editor->setEmail('editor@example.com');
+    $editor->addRole('editor');
+    $editor->save();
+    \Drupal::service('account_switcher')->switchTo($editor);
+
+    $this->author = $this->createUser();
+    $this->author->setEmail('author@example.com');
+    $this->author->save();
+
+    $this->approver = $this->createUser();
+    $this->approver->setEmail('approver@example.com');
+    $this->approver->save();
+  }
+
+  /**
+   * Data provider for testDelivery.
+   *
+   * @return array
+   *   Test cases.
+   */
+  public function providerDelivery() {
+    return [
+      'author' => [
+        'author',
+        ['author@example.com'],
+      ],
+      'role' => [
+        'role',
+        ['editor@example.com'],
+        [
+          'roles' => ['editor'],
+        ],
+        ['user.role.editor'],
+      ],
+      'email field' => [
+        'email',
+        ['random@example.com'],
+        [
+          'fields' => ['node:field_email'],
+        ],
+        ['field.storage.node.field_email'],
+      ],
+      'entity reference field' => [
+        'entity_reference_user',
+        ['approver@example.com'],
+        [
+          'fields' => ['node:field_approver'],
+        ],
+        ['field.storage.node.field_approver'],
+      ],
+    ];
+  }
+
+  /**
+   * Tests recipient delivery.
+   *
+   * @param string $pluginId
+   *   Recipient plugin ID.
+   * @param array $expectedRecipients
+   *   Expected recipients.
+   * @param array $settings
+   *   Plugin settings.
+   * @param array $expectedDependencies
+   *   Expected configuration dependencies.
+   *
+   * @throws \Drupal\Core\Entity\EntityStorageException
+   *
+   * @dataProvider providerDelivery
+   */
+  public function testDelivery($pluginId, array $expectedRecipients, array $settings = [], array $expectedDependencies = []) {
+    $template = Template::create([
+      'id' => 'test',
+      'label' => 'Test',
+      'body' => [
+        'value' => 'Content with title [node:title] needs review.',
+        'format' => 'plain_text',
+      ],
+      'subject' => 'Content needs review: [node:title]',
+      'recipient_types' => [
+        $pluginId => [
+          'id' => $pluginId,
+          'provider' => 'workbench_email',
+          'status' => 1,
+          'settings' => $settings,
+        ],
+      ],
+    ]);
+    $template->save();
+    if ($expectedDependencies) {
+      $dependencies = $template->calculateDependencies()->getDependencies()['config'];
+      $this->assertEquals($expectedDependencies, $dependencies);
+    }
+    $transition = ModerationStateTransition::load('draft_needs_review');
+    $transition->setThirdPartySetting('workbench_email', 'workbench_email_templates', ['test' => 'test']);
+    $transition->save();
+    $this->assertContains('workbench_email.workbench_email_template.test', $transition->calculateDependencies()->getDependencies()['config']);
+
+    $node = Node::create([
+      'title' => 'test',
+      'uid' => $this->author->id(),
+      'type' => 'test',
+      'field_email' => 'random@example.com',
+      'field_approver' => $this->approver->id(),
+      'moderation_state' => 'draft',
+    ]);
+    $node->save();
+
+    // Reset email.
+    $this->container->get('state')->set('system.test_mail_collector', []);
+
+    // Send for review.
+    $node->moderation_state = 'needs_review';
+    $node->save();
+
+    // Check mail goes to recipients.
+    $captured_emails = $this->container->get('state')->get('system.test_mail_collector') ?: [];
+    $this->assertEquals($expectedRecipients, array_map(function (array $mail) {
+      return $mail['to'];
+    }, $captured_emails));
+    foreach ($captured_emails as $email) {
+      $this->assertEquals(sprintf('Content needs review: %s', $node->getTitle()), $email['subject']);
+      $this->assertContains(sprintf('Content with title %s needs review.', $node->label()), preg_replace('/\s+/', ' ', $email['body']));
+    }
+  }
+
+}
diff --git a/tests/src/Traits/WorkbenchEmailTestTrait.php b/tests/src/Traits/WorkbenchEmailTestTrait.php
new file mode 100644
index 0000000..e084931
--- /dev/null
+++ b/tests/src/Traits/WorkbenchEmailTestTrait.php
@@ -0,0 +1,61 @@
+<?php
+
+namespace Drupal\Tests\workbench_email\Traits;
+
+use Drupal\Core\Entity\Entity\EntityFormDisplay;
+use Drupal\field\Entity\FieldConfig;
+use Drupal\field\Entity\FieldStorageConfig;
+use Drupal\node\NodeTypeInterface;
+use Drupal\workbench_moderation\Entity\ModerationState;
+
+/**
+ * Contains helper classes for tests to set up various configuration.
+ */
+trait WorkbenchEmailTestTrait {
+
+  /**
+   * Enables moderation for a given node type.
+   *
+   * @param \Drupal\node\NodeTypeInterface $node_type
+   *   Node type to enable moderation for.
+   */
+  protected function setUpModerationForNodeType(NodeTypeInterface $node_type) {
+    $node_type->setThirdPartySetting('workbench_moderation', 'enabled', TRUE);
+    $states = array_keys(ModerationState::loadMultiple());
+    $node_type->setThirdPartySetting('workbench_moderation', 'allowed_moderation_states', $states);
+    $node_type->setThirdPartySetting('workbench_moderation', 'default_moderation_state', 'draft');
+    $node_type->save();
+  }
+
+  /**
+   * Adds an email field to a node bundle.
+   *
+   * @param string $bundle
+   *   (optional) Bundle name. Defaults to 'test'.
+   */
+  protected function setUpEmailFieldForNodeBundle($bundle = 'test') {
+    // Add an email field notify to the bundle.
+    FieldStorageConfig::create([
+      'cardinality' => 1,
+      'entity_type' => 'node',
+      'field_name' => 'field_email',
+      'type' => 'email',
+    ])->save();
+    FieldConfig::create([
+      'field_name' => 'field_email',
+      'bundle' => 'test',
+      'label' => 'Notify',
+      'entity_type' => 'node',
+    ])->save();
+    if (!$entity_form_display = EntityFormDisplay::load(sprintf('node.%s.default', $bundle))) {
+      $entity_form_display = EntityFormDisplay::create([
+        'targetEntityType' => 'node',
+        'bundle' => $bundle,
+        'mode' => 'default',
+        'status' => TRUE,
+      ]);
+    }
+    $entity_form_display->setComponent('field_email', ['type' => 'email_default'])->save();
+  }
+
+}
diff --git a/workbench_email.links.action.yml b/workbench_email.links.action.yml
index de74537..001c403 100644
--- a/workbench_email.links.action.yml
+++ b/workbench_email.links.action.yml
@@ -3,4 +3,3 @@ entity.workbench_email_template.add_form:
   title: 'Add Email Template'
   appears_on:
     - entity.workbench_email_template.collection
-
diff --git a/workbench_email.links.menu.yml b/workbench_email.links.menu.yml
index c5733f2..524cde8 100644
--- a/workbench_email.links.menu.yml
+++ b/workbench_email.links.menu.yml
@@ -4,4 +4,3 @@ entity.workbench_email_template.collection:
   description: 'Manage Email Templates'
   parent: workbench_moderation.overview
   weight: 99
-
diff --git a/workbench_email.module b/workbench_email.module
index 594f195..0702758 100644
--- a/workbench_email.module
+++ b/workbench_email.module
@@ -4,6 +4,7 @@
  * @file
  * Provides main module functions.
  */
+
 use Drupal\Core\Form\FormStateInterface;
 use Drupal\Core\Mail\MailFormatHelper;
 use Drupal\Core\Entity\EntityInterface;
@@ -19,7 +20,7 @@ function workbench_email_help($route_name, RouteMatchInterface $route_match) {
   switch ($route_name) {
     case 'entity.workbench_email_template.collection':
     case 'help.page.workbench_email':
-      return '<p>' . t("The Workbench Moderation Email module keeps track of when a piece of entity transitions from one state to another. Admins can create new templates to manage the contents and recipients of email sent when those transitions happen.") . '</p><p>Each template can be attached to a transition by editing the transition and selecting the templates to use.</p>';
+      return '<p>' . t("The Workbench Moderation Email module keeps track of when a piece of entity transitions from one state to another. Admins can create new templates to manage the contents and recipients of email sent when those transitions happen.") . '</p><p>' . t('Each template can be attached to a transition by editing the transition and selecting the templates to use.') . '</p>';
   }
 }
 
@@ -28,7 +29,7 @@ function workbench_email_help($route_name, RouteMatchInterface $route_match) {
  */
 function workbench_email_form_moderation_state_transition_edit_form_alter(&$form, FormStateInterface $form_state) {
   // Alter the transition form to add the fields to choose the templates.
-  /** @var ModerationStateTransitionInterface $transition */
+  /** @var \Drupal\workbench_moderation\ModerationStateTransitionInterface $transition */
 
   $form_object = $form_state->getFormObject();
   if (!in_array($form_object->getOperation(), ['edit', 'add'], TRUE)) {
@@ -72,8 +73,10 @@ function workbench_email_moderation_state_transition_presave(ModerationStateTran
     foreach ($transition->getThirdPartySetting('workbench_email', 'workbench_email_templates', []) as $template) {
       $dependencies['enforced']['config'][] = 'workbench_email.workbench_email_template.' . $template;
     }
-    // Ensure no duplicates.
-    $dependencies['enforced']['config'] = array_unique($dependencies['enforced']['config']);
+    if (!empty($dependencies['enforced']['config'])) {
+      // Ensure no duplicates.
+      $dependencies['enforced']['config'] = array_unique($dependencies['enforced']['config']);
+    }
     $transition->set('dependencies', $dependencies);
   }
 }
diff --git a/workbench_email.post_update.php b/workbench_email.post_update.php
new file mode 100644
index 0000000..05ca4b1
--- /dev/null
+++ b/workbench_email.post_update.php
@@ -0,0 +1,51 @@
+<?php
+
+/**
+ * @file
+ * Contains post update hooks.
+ */
+
+use Drupal\Core\Config\Entity\ConfigEntityUpdater;
+use Drupal\workbench_email\TemplateInterface;
+
+/**
+ * Updates config entities to use the new recipient plugins.
+ */
+function workbench_email_post_update_move_to_recipient_plugins(&$sandbox = NULL) {
+  \Drupal::classResolver(ConfigEntityUpdater::class)->update($sandbox, 'workbench_email_template', function (TemplateInterface $template) {
+    $plugins = [];
+    if ($template->get('author')) {
+      $plugins['author'] = [
+        'id' => 'author',
+        'provider' => 'workbench_email',
+        'status' => TRUE,
+        'settings' => [],
+      ];
+    }
+    if ($roles = $template->get('roles')) {
+      $plugins['role'] = [
+        'id' => 'role',
+        'provider' => 'workbench_email',
+        'status' => TRUE,
+        'settings' => [
+          'roles' => $roles,
+        ],
+      ];
+    }
+    if ($fields = $template->get('fields')) {
+      $plugins['email'] = [
+        'id' => 'email',
+        'provider' => 'workbench_email',
+        'status' => TRUE,
+        'settings' => [
+          'fields' => $fields,
+        ],
+      ];
+    }
+    $template->set('recipient_types', $plugins);
+    $template->set('fields', NULL);
+    $template->set('roles', NULL);
+    $template->set('author', NULL);
+    return TRUE;
+  });
+}
diff --git a/workbench_email.services.yml b/workbench_email.services.yml
index 98a4cfe..d26d931 100644
--- a/workbench_email.services.yml
+++ b/workbench_email.services.yml
@@ -1,4 +1,7 @@
 services:
+  plugin.manager.recipient_type:
+    class: Drupal\workbench_email\RecipientTypePluginManager
+    parent: default_plugin_manager
   workbench_email.subscriber.workbench_transition:
     class: Drupal\workbench_email\EventSubscriber\WorkbenchTransitionEventSubscriber
     arguments: ['@entity_type.manager', '@current_user', '@queue']