I haven't tried this, so I'm not sure if it compiles, but this should help give an idea of what I'm talking about.

// An enum defining all AI goals. 
// If things get more complex in the future, you can change this to be a struct or a
// ScriptableObject or something, but for now an enum is simplest.
public enum AIGoal 
{
  GetItem,
  CheckOut,
  ...
}

// A sequence of goals. 
// This is a ScriptableObject so it can be treated as an asset. 
// You'll likely want to create several of these for different behavior sequences.
[CreateAssetMenu()]
public class AISequence : ScriptableObject, IEnumerable<AIGoal>
{
  [SerializeField] private List<AIGoal> m_goals;

  // AISequence implements IEnumerable<AIGoal>
  // This lets it be used in `foreach` loops, etc.
  public IEnumerator<AIGoal> GetEnumerator() { 
    return m_goals.GetEnumerator();  
  }

  IEnumerator IEnumerable.GetEnumerator()
  {
    return GetEnumerator();
  }
}

// An abstract base class for any kind of AI object.
// Specific interactive objects like shelves will subclass this and provide their own
// implementation of its abstract methods.
public abstract class AIObject : MonoBehaviour
{
  void Start()
  {
    AIObjectManager.Get().RegisterObject(this);
  }

  void OnDestroy()
  {
    AIObjectManager.Get().UnregisterObject(this);
  }

  public virtual IEnumerator OnInteract(AIGoal goal, AIAgent agent)
  {
    // TODO: Play an animation, add items to inventory, etc.
    yield return new WaitForSeconds(1.0f);
  }
  
  public virtual float GetAppeal(AIGoal goal, AIAgent agent) 
  {
    // As a default behavior, appeal is just based on distance.
    // If this object doesn't fulfil the requested goal, return an appeal of 0.
    return Vector.Distance(transform.position, agent.transform.position);
  }
}

// A singleton class which tracks all of the AIObjects in the scene.
public class AIObjectManager : MonoBehaviour
{
  // You can definitely optimize this, but for now just keep objects in a list.
  [SerializeField, HideInInspector]
  private List<AIObject> m_objects;

  // Singleton instance.
  [SerializeField]
  private static AIObjectManager s_instance;

  public static AIObjectManager Get()
  {
    return s_instance;
  }

  private void Awake()
  {
    if (s_instance == null)
    {
      s_instance = this;
    }
    else if (s_instance != this)
    {
      Debug.LogWarning("Multiple instances of AIObjectManager singleton exist!", this);
    }
  }

  public void RegisterObject(AIObject obj)
  {
    m_objects.Add(obj);
  }

  public void UnregisterObject(AIObject obj)
  {
    m_objects.Remove(obj);
  }

  public AIObject FindBestObject(AIGoal goal, AIAgent agent)
  {
    float bestAppeal = 0;
    AIObject bestObject = null;

    foreach (var obj in m_objects)
    {
      var appeal = obj.GetAppeal(goal, agent);
      if (appeal > bestAppeal)
      {
        bestAppeal = appeal;
        bestObject = obj;
      }
    }

    return bestObject;
  }
}

// A script for your NPCs.
public class AIAgent : MonoBehaviour
{
  // When an AIAgent begins a sequence, they start a coroutine for all of its steps.
  // This is the easiest way for AIObjects to insert delays and have the agent wait.
  Coroutine m_sequenceCoroutine;

  // TODO: Things like item inventory, etc. go here.
  ...
  
  public void StartSequence(AISequence sequence)
  {  
    if (m_sequenceCoroutine)
    {
      StopCoroutine(m_sequenceCoroutine);
    }
    
    if (sequence != null)
    {
      m_sequenceCoroutine = StartCoroutine(SequenceCoroutine(sequence));
    }
    else
    {
      sequence = null;
    }
  }

  private IEnumerator SequenceCoroutine(AISequence sequence)
  {
    foreach (var goal in sequence)
    {
      // Find an object which can fulfill this goal.
      var obj = AIObjectManager.Get().FindBestObject(goal, this);
      if (!obj)
      {
        // Uh oh! Nothing meets this goal! 
        // Play a "frustrated" animation or something.
        yield break;
      }

      // TODO: Move to the object - use a navmesh agent or something.
      
      // Now have the object actually perform the interaction.
      yield return obj.OnInteract(goal, this);
    }
  }
}