diff --git a/src/main/java/seedu/address/commons/core/Messages.java b/src/main/java/seedu/address/commons/core/Messages.java
index 1deb3a1e4695..12e2d2b64ee8 100644
--- a/src/main/java/seedu/address/commons/core/Messages.java
+++ b/src/main/java/seedu/address/commons/core/Messages.java
@@ -8,6 +8,7 @@ public class Messages {
     public static final String MESSAGE_UNKNOWN_COMMAND = "Unknown command";
     public static final String MESSAGE_INVALID_COMMAND_FORMAT = "Invalid command format! \n%1$s";
     public static final String MESSAGE_INVALID_PERSON_DISPLAYED_INDEX = "The person index provided is invalid";
+    public static final String MESSAGE_INVALID_EVENT_DISPLAYED_INDEX = "The event index provided is invalid";
     public static final String MESSAGE_PERSONS_LISTED_OVERVIEW = "%1$d persons listed!";
 
 }
diff --git a/src/main/java/seedu/address/logic/commands/AddECommand.java b/src/main/java/seedu/address/logic/commands/AddECommand.java
new file mode 100644
index 000000000000..e1e66d72efcf
--- /dev/null
+++ b/src/main/java/seedu/address/logic/commands/AddECommand.java
@@ -0,0 +1,71 @@
+package seedu.address.logic.commands;
+
+import static java.util.Objects.requireNonNull;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_DESCRIPTION;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_END_TIME;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_LABEL;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_NAME;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_START_TIME;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_VENUE;
+
+import seedu.address.logic.CommandHistory;
+import seedu.address.logic.commands.exceptions.CommandException;
+import seedu.address.model.Model;
+import seedu.address.model.event.Event;
+
+/**
+ * Adds a person to the address book.
+ */
+public class AddECommand extends Command {
+
+    public static final String COMMAND_WORD = "addE";
+
+    public static final String MESSAGE_USAGE = COMMAND_WORD + ": Adds an event to the address book. "
+            + "Parameters: "
+            + PREFIX_NAME + "NAME "
+            + PREFIX_DESCRIPTION + "DESCRIPTION "
+            + PREFIX_VENUE + "VENUE "
+            + PREFIX_START_TIME + "START_TIME "
+            + PREFIX_END_TIME + "END_TIME "
+            + PREFIX_LABEL + "LABEL\n"
+            + "Example: " + COMMAND_WORD + " "
+            + PREFIX_NAME + " "
+            + PREFIX_DESCRIPTION + "CS2103 project meeting "
+            + PREFIX_VENUE + "com1 level2 "
+            + PREFIX_START_TIME + "2019-01-31 14:00:00 "
+            + PREFIX_END_TIME + "2019-01-31 16:00:00 "
+            + PREFIX_LABEL + "URGENT";
+
+    public static final String MESSAGE_SUCCESS = "New event added: %1$s";
+    public static final String MESSAGE_DUPLICATE_EVENT = "This event already exists in the address book";
+
+    private final Event toAdd;
+
+    /**
+     * Creates an AddECommand to add the specified {@code Event}
+     */
+    public AddECommand(Event event) {
+        requireNonNull(event);
+        toAdd = event;
+    }
+
+    @Override
+    public CommandResult execute(Model model, CommandHistory history) throws CommandException {
+        requireNonNull(model);
+
+        if (model.hasEvent(toAdd)) {
+            throw new CommandException(MESSAGE_DUPLICATE_EVENT);
+        }
+
+        model.addEvent(toAdd);
+        model.commitAddressBook();
+        return new CommandResult(String.format(MESSAGE_SUCCESS, toAdd));
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other == this // short circuit if same object
+                || (other instanceof AddECommand // instanceof handles nulls
+                && toAdd.equals(((AddECommand) other).toAdd));
+    }
+}
diff --git a/src/main/java/seedu/address/logic/commands/DeleteECommand.java b/src/main/java/seedu/address/logic/commands/DeleteECommand.java
new file mode 100644
index 000000000000..4b7ed7aa1715
--- /dev/null
+++ b/src/main/java/seedu/address/logic/commands/DeleteECommand.java
@@ -0,0 +1,56 @@
+package seedu.address.logic.commands;
+
+import static java.util.Objects.requireNonNull;
+
+import java.util.List;
+
+import seedu.address.commons.core.Messages;
+import seedu.address.commons.core.index.Index;
+import seedu.address.logic.CommandHistory;
+import seedu.address.logic.commands.exceptions.CommandException;
+import seedu.address.model.Model;
+import seedu.address.model.event.Event;
+
+
+/**
+ * Deletes an event identified using it's displayed index from the address book.
+ */
+public class DeleteECommand extends Command {
+
+    public static final String COMMAND_WORD = "deleteE";
+
+    public static final String MESSAGE_USAGE = COMMAND_WORD
+            + ": Deletes the event identified by the index number used in the displayed event list.\n"
+            + "Parameters: INDEX (must be a positive integer)\n"
+            + "Example: " + COMMAND_WORD + " 1";
+
+    public static final String MESSAGE_DELETE_EVENT_SUCCESS = "Deleted Event: %1$s";
+
+    private final Index targetIndex;
+
+    public DeleteECommand(Index targetIndex) {
+        this.targetIndex = targetIndex;
+    }
+
+    @Override
+    public CommandResult execute(Model model, CommandHistory history) throws CommandException {
+        requireNonNull(model);
+        List<Event> lastShownList = model.getFilteredEventList();
+
+        if (targetIndex.getZeroBased() >= lastShownList.size()) {
+            throw new CommandException(Messages.MESSAGE_INVALID_EVENT_DISPLAYED_INDEX);
+        }
+
+        Event eventToDelete = lastShownList.get(targetIndex.getZeroBased());
+        model.deleteEvent(eventToDelete);
+        model.commitAddressBook();
+        return new CommandResult(String.format(MESSAGE_DELETE_EVENT_SUCCESS, eventToDelete));
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other == this // short circuit if same object
+                || (other instanceof DeleteECommand // instanceof handles nulls
+                && targetIndex.equals(((DeleteECommand) other).targetIndex)); // state check
+    }
+}
diff --git a/src/main/java/seedu/address/logic/commands/EditECommand.java b/src/main/java/seedu/address/logic/commands/EditECommand.java
new file mode 100644
index 000000000000..70d58713e591
--- /dev/null
+++ b/src/main/java/seedu/address/logic/commands/EditECommand.java
@@ -0,0 +1,254 @@
+package seedu.address.logic.commands;
+
+import static java.util.Objects.requireNonNull;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_DESCRIPTION;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_END_TIME;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_LABEL;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_NAME;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_START_TIME;
+import static seedu.address.logic.parser.CliSyntax.PREFIX_VENUE;
+import static seedu.address.model.Model.PREDICATE_SHOW_ALL_EVENTS;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Optional;
+import java.util.Set;
+
+import seedu.address.commons.core.Messages;
+import seedu.address.commons.core.index.Index;
+import seedu.address.commons.util.CollectionUtil;
+import seedu.address.logic.CommandHistory;
+import seedu.address.logic.commands.exceptions.CommandException;
+import seedu.address.model.Model;
+import seedu.address.model.event.DateTime;
+import seedu.address.model.event.Description;
+import seedu.address.model.event.Event;
+import seedu.address.model.event.Label;
+import seedu.address.model.event.Name;
+import seedu.address.model.event.Venue;
+import seedu.address.model.person.Person;
+
+/**
+ * Edits the details of an existing event in the address book.
+ */
+public class EditECommand extends Command {
+
+    public static final String COMMAND_WORD = "editE";
+
+    public static final String MESSAGE_USAGE = COMMAND_WORD + ": Edits the details of the event identified "
+            + "by the index number used in the displayed event list. "
+            + "Existing values will be overwritten by the input values.\n"
+            + "Parameters: INDEX (must be a positive integer) "
+            + "[" + PREFIX_NAME + "NAME] "
+            + "[" + PREFIX_DESCRIPTION + "DESCRIPTION] "
+            + "[" + PREFIX_VENUE + "VENUE] "
+            + "[" + PREFIX_START_TIME + "START_TIME] "
+            + "[" + PREFIX_END_TIME + "END_TIME] "
+            + "[" + PREFIX_LABEL + "LABEL] \n"
+            + "Example: " + COMMAND_WORD + " 1 "
+            + PREFIX_VENUE + "BIZ2 level4 "
+            + PREFIX_LABEL + "IMPORTANT";
+
+    public static final String MESSAGE_EDIT_EVENT_SUCCESS = "Edited Event: %1$s";
+    public static final String MESSAGE_NOT_EDITED = "At least one field to edit must be provided.";
+    public static final String MESSAGE_DUPLICATE_EVENT = "This event already exists in the address book.";
+
+    private final Index index;
+    private final EditEventDescriptor editEventDescriptor;
+
+    /**
+     * @param index of the event in the filtered event list to edit
+     * @param editEventDescriptor details to edit the event with
+     */
+    public EditECommand(Index index, EditEventDescriptor editEventDescriptor) {
+        requireNonNull(index);
+        requireNonNull(editEventDescriptor);
+
+        this.index = index;
+        this.editEventDescriptor = new EditEventDescriptor(editEventDescriptor);
+    }
+
+    @Override
+    public CommandResult execute(Model model, CommandHistory history) throws CommandException {
+        requireNonNull(model);
+        List<Event> lastShownList = model.getFilteredEventList();
+
+        if (index.getZeroBased() >= lastShownList.size()) {
+            throw new CommandException(Messages.MESSAGE_INVALID_EVENT_DISPLAYED_INDEX);
+        }
+
+        Event eventToEdit = lastShownList.get(index.getZeroBased());
+        Event editedEvent = createEditedEvent(eventToEdit, editEventDescriptor);
+
+        if (!eventToEdit.isSameEvent(editedEvent) && model.hasEvent(editedEvent)) {
+            throw new CommandException(MESSAGE_DUPLICATE_EVENT);
+        }
+
+        model.setEvent(eventToEdit, editedEvent);
+        model.updateFilteredEventList(PREDICATE_SHOW_ALL_EVENTS);
+        model.commitAddressBook();
+        return new CommandResult(String.format(MESSAGE_EDIT_EVENT_SUCCESS, editedEvent));
+    }
+
+    /**
+     * Creates and returns a {@code Event} with the details of {@code eventToEdit}
+     * edited with {@code editEventDescriptor}.
+     */
+    private static Event createEditedEvent(Event eventToEdit, EditEventDescriptor editEventDescriptor) {
+        assert eventToEdit != null;
+
+        Name updatedName = editEventDescriptor.getName().orElse(eventToEdit.getName());
+        Description updatedDescription = editEventDescriptor.getDescription().orElse(eventToEdit.getDescription());
+        Venue updatedVenue = editEventDescriptor.getVenue().orElse(eventToEdit.getVenue());
+        DateTime updatedStartTime = editEventDescriptor.getStartDateTime().orElse(eventToEdit.getStartDateTime());
+        DateTime updatedEndTime = editEventDescriptor.getEndDateTime().orElse(eventToEdit.getEndDateTime());
+        Label updatedLabel = editEventDescriptor.getLabel().orElse(eventToEdit.getLabel());
+        Set<Person> updatedPersons = editEventDescriptor.getPersons().orElse(eventToEdit.getPersons());
+
+        return new Event(updatedName, updatedDescription, updatedVenue, updatedStartTime, updatedEndTime, updatedLabel,
+                updatedPersons);
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        // short circuit if same object
+        if (other == this) {
+            return true;
+        }
+
+        // instanceof handles nulls
+        if (!(other instanceof EditECommand)) {
+            return false;
+        }
+
+        // state check
+        EditECommand e = (EditECommand) other;
+        return index.equals(e.index)
+                && editEventDescriptor.equals(e.editEventDescriptor);
+    }
+
+    /**
+     * Stores the details to edit the event with. Each non-empty field value will replace the
+     * corresponding field value of the event.
+     */
+    public static class EditEventDescriptor {
+        private Name name;
+        private Description description;
+        private Venue venue;
+        private DateTime startDateTime;
+        private DateTime endDateTime;
+        private Label label;
+        private Set<Person> persons;
+
+        public EditEventDescriptor() {}
+
+        /**
+         * Copy constructor.
+         * A defensive copy of {@code tags} is used internally.
+         */
+        public EditEventDescriptor(EditEventDescriptor toCopy) {
+            setName(toCopy.name);
+            setDescription(toCopy.description);
+            setVenue(toCopy.venue);
+            setStartDateTime(toCopy.startDateTime);
+            setEndDateTime(toCopy.endDateTime);
+            setLabel(toCopy.label);
+            setPersons(toCopy.persons);
+        }
+
+        /**
+         * Returns true if at least one field is edited.
+         */
+        public boolean isAnyFieldEdited() {
+            return CollectionUtil.isAnyNonNull(name, description, venue, startDateTime, endDateTime, label);
+        }
+
+        public void setName(Name name) {
+            this.name = name;
+        }
+
+        public Optional<Name> getName() {
+            return Optional.ofNullable(name);
+        }
+
+        public void setDescription(Description description) {
+            this.description = description;
+        }
+
+        public Optional<Description> getDescription() {
+            return Optional.ofNullable(description);
+        }
+
+        public void setVenue(Venue venue) {
+            this.venue = venue;
+        }
+
+        public Optional<Venue> getVenue() {
+            return Optional.ofNullable(venue);
+        }
+
+        public void setStartDateTime(DateTime startDateTime) {
+            this.startDateTime = startDateTime;
+        }
+
+        public Optional<DateTime> getStartDateTime() {
+            return Optional.ofNullable(startDateTime);
+        }
+
+        public void setEndDateTime(DateTime endDateTime) {
+            this.endDateTime = endDateTime;
+        }
+
+        public Optional<DateTime> getEndDateTime() {
+            return Optional.ofNullable(endDateTime);
+        }
+
+        public void setLabel(Label label) {
+            this.label = label;
+        }
+
+        public Optional<Label> getLabel() {
+            return Optional.ofNullable(label);
+        }
+
+        /**
+         * Sets {@code persons} to this object's {@code persons}.
+         * A defensive copy of {@code persons} is used internally.
+         */
+        public void setPersons(Set<Person> persons) {
+            this.persons = (persons != null) ? new HashSet<>(persons) : null;
+        }
+
+        /**
+         * Returns an unmodifiable person set, which throws {@code UnsupportedOperationException}
+         * if modification is attempted.
+         * Returns {@code Optional#empty()} if {@code persons} is null.
+         */
+        public Optional<Set<Person>> getPersons() {
+            return (persons != null) ? Optional.of(Collections.unmodifiableSet(persons)) : Optional.empty();
+        }
+
+        @Override
+        public boolean equals(Object other) {
+            // short circuit if same object
+            if (other == this) {
+                return true;
+            }
+
+            // instanceof handles nulls
+            if (!(other instanceof EditEventDescriptor)) {
+                return false;
+            }
+
+            // state check
+            EditEventDescriptor e = (EditEventDescriptor) other;
+
+            return getName().equals(e.getName())
+                    && getDescription().equals(e.getDescription())
+                    && getVenue().equals(e.getVenue())
+                    && getStartDateTime().equals(e.getStartDateTime())
+                    && getEndDateTime().equals(e.getEndDateTime());
+        }
+    }
+}
diff --git a/src/main/java/seedu/address/logic/commands/ListECommand.java b/src/main/java/seedu/address/logic/commands/ListECommand.java
new file mode 100644
index 000000000000..15fd39f4d9ec
--- /dev/null
+++ b/src/main/java/seedu/address/logic/commands/ListECommand.java
@@ -0,0 +1,28 @@
+package seedu.address.logic.commands;
+
+import static java.util.Objects.requireNonNull;
+import static seedu.address.model.Model.PREDICATE_SHOW_ALL_EVENTS;
+
+import seedu.address.logic.CommandHistory;
+import seedu.address.model.Model;
+
+/**
+ * Lists all events in the address book to the user.
+ */
+public class ListECommand extends Command {
+
+    public static final String COMMAND_WORD = "listE";
+
+    public static final String MESSAGE_SUCCESS = "Listed all events";
+
+
+    @Override
+    public CommandResult execute(Model model, CommandHistory history) {
+        requireNonNull(model);
+        model.updateFilteredEventList(PREDICATE_SHOW_ALL_EVENTS);
+        return new CommandResult(MESSAGE_SUCCESS);
+    }
+}
+
+
+
diff --git a/src/main/java/seedu/address/logic/parser/CliSyntax.java b/src/main/java/seedu/address/logic/parser/CliSyntax.java
index 1b4ff730c73f..567924ae9971 100644
--- a/src/main/java/seedu/address/logic/parser/CliSyntax.java
+++ b/src/main/java/seedu/address/logic/parser/CliSyntax.java
@@ -12,4 +12,9 @@ public class CliSyntax {
     public static final Prefix PREFIX_ADDRESS = new Prefix("a/");
     public static final Prefix PREFIX_TAG = new Prefix("t/");
     public static final Prefix PREFIX_AVATOR = new Prefix("av/");
+    public static final Prefix PREFIX_DESCRIPTION = new Prefix("d/");
+    public static final Prefix PREFIX_VENUE = new Prefix("n/");
+    public static final Prefix PREFIX_START_TIME = new Prefix("s/");
+    public static final Prefix PREFIX_END_TIME = new Prefix("e/");
+    public static final Prefix PREFIX_LABEL = new Prefix("l/");
 }
diff --git a/src/main/java/seedu/address/model/AddressBook.java b/src/main/java/seedu/address/model/AddressBook.java
index 30557cf81ee7..78577f539cfa 100644
--- a/src/main/java/seedu/address/model/AddressBook.java
+++ b/src/main/java/seedu/address/model/AddressBook.java
@@ -7,6 +7,8 @@
 import javafx.beans.InvalidationListener;
 import javafx.collections.ObservableList;
 import seedu.address.commons.util.InvalidationListenerManager;
+import seedu.address.model.event.Event;
+import seedu.address.model.event.UniqueEventList;
 import seedu.address.model.person.Person;
 import seedu.address.model.person.UniquePersonList;
 
@@ -17,6 +19,7 @@
 public class AddressBook implements ReadOnlyAddressBook {
 
     private final UniquePersonList persons;
+    private final UniqueEventList events;
     private final InvalidationListenerManager invalidationListenerManager = new InvalidationListenerManager();
 
     /*
@@ -28,6 +31,7 @@ public class AddressBook implements ReadOnlyAddressBook {
      */
     {
         persons = new UniquePersonList();
+        events = new UniqueEventList();
     }
 
     public AddressBook() {}
@@ -58,6 +62,7 @@ public void resetData(ReadOnlyAddressBook newData) {
         requireNonNull(newData);
 
         setPersons(newData.getPersonList());
+        setEvents(newData.getEventList());
     }
 
     //// person-level operations
@@ -134,11 +139,66 @@ public ObservableList<Person> getPersonList() {
     public boolean equals(Object other) {
         return other == this // short circuit if same object
                 || (other instanceof AddressBook // instanceof handles nulls
-                && persons.equals(((AddressBook) other).persons));
+                && persons.equals(((AddressBook) other).persons))
+                && events.equals(((AddressBook) other).events);
     }
 
     @Override
     public int hashCode() {
         return persons.hashCode();
     }
+
+
+    /**
+     * Replaces the contents of the event list with {@code events}.
+     * {@code events} must not contain duplicate events.
+     */
+    public void setEvents(List<Event> events) {
+        this.events.setEvents(events);
+        indicateModified();
+    }
+
+    //event-level operation
+    /**
+     * Returns true if a event with the same identity as {@code event} exists in the address book.
+     */
+    public boolean hasEvent(Event event) {
+        requireNonNull(event);
+        return events.contains(event);
+    }
+
+    /**
+     * Adds an event to the address book.
+     * The event must not already exist in the address book.
+     */
+    public void addEvent(Event event) {
+        events.add(event);
+        indicateModified();
+    }
+    /**
+     * Replaces the given event {@code target} in the list with {@code editedEvent}.
+     * {@code target} must exist in the address book.
+     * The event identity of {@code editedEvent} must not be the same as another existing event in the address book.
+     */
+    public void setEvent(Event target, Event editedEvent) {
+        requireNonNull(editedEvent);
+
+        events.setEvent(target, editedEvent);
+        indicateModified();
+    }
+
+    /**
+     * Removes {@code key} from this {@code AddressBook}.
+     * {@code key} must exist in the address book.
+     */
+    public void removeEvent(Event key) {
+        events.remove(key);
+        indicateModified();
+    }
+
+    @Override
+    public ObservableList<Event> getEventList() {
+        return events.asUnmodifiableObservableList();
+    }
+
 }
diff --git a/src/main/java/seedu/address/model/Model.java b/src/main/java/seedu/address/model/Model.java
index e857533821b6..e2402f3af963 100644
--- a/src/main/java/seedu/address/model/Model.java
+++ b/src/main/java/seedu/address/model/Model.java
@@ -6,6 +6,7 @@
 import javafx.beans.property.ReadOnlyProperty;
 import javafx.collections.ObservableList;
 import seedu.address.commons.core.GuiSettings;
+import seedu.address.model.event.Event;
 import seedu.address.model.person.Person;
 
 /**
@@ -14,6 +15,7 @@
 public interface Model {
     /** {@code Predicate} that always evaluate to true */
     Predicate<Person> PREDICATE_SHOW_ALL_PERSONS = unused -> true;
+    Predicate<Event> PREDICATE_SHOW_ALL_EVENTS = unused -> true;
 
     /**
      * Replaces user prefs data with the data in {@code userPrefs}.
@@ -127,4 +129,54 @@ public interface Model {
      * Sets the selected person in the filtered person list.
      */
     void setSelectedPerson(Person person);
+
+    /**
+     * Returns true if an event with the same identity as {@code event} exists in the address book.
+     */
+    boolean hasEvent(Event event);
+
+    /**
+     * Deletes the given event.
+     * The event must exist in the address book.
+     */
+    void deleteEvent(Event event);
+
+    /**
+     * Adds the given event.
+     * {@code event} must not already exist in the address book.
+     */
+    void addEvent(Event event);
+
+    /**
+     * Replaces the given event {@code target} with {@code editedEvent}.
+     * {@code target} must exist in the address book.
+     * The event identity of {@code editedEvent} must not be the same as another existing event in the address book.
+     */
+    void setEvent(Event target, Event editedEvent);
+
+    /** Returns an unmodifiable view of the filtered event list */
+    ObservableList<Event> getFilteredEventList();
+
+    /**
+     * Updates the filter of the filtered event list to filter by the given {@code predicate}.
+     * @throws NullPointerException if {@code predicate} is null.
+     */
+    void updateFilteredEventList(Predicate<Event> predicate);
+
+    /**
+     * Selected event in the filtered event list.
+     * null if no event is selected.
+     */
+    ReadOnlyProperty<Event> selectedEventProperty();
+
+    /**
+     * Returns the selected event in the filtered event list.
+     * null if no event is selected.
+     */
+    Event getSelectedEvent();
+
+    /**
+     * Sets the selected event in the filtered event list.
+     */
+    void setSelectedEvent(Event event);
 }
diff --git a/src/main/java/seedu/address/model/ModelManager.java b/src/main/java/seedu/address/model/ModelManager.java
index b56806232814..9ab3ef0d74d7 100644
--- a/src/main/java/seedu/address/model/ModelManager.java
+++ b/src/main/java/seedu/address/model/ModelManager.java
@@ -15,6 +15,8 @@
 import javafx.collections.transformation.FilteredList;
 import seedu.address.commons.core.GuiSettings;
 import seedu.address.commons.core.LogsCenter;
+import seedu.address.model.event.Event;
+import seedu.address.model.event.exceptions.EventNotFoundException;
 import seedu.address.model.person.Person;
 import seedu.address.model.person.exceptions.PersonNotFoundException;
 
@@ -27,7 +29,9 @@ public class ModelManager implements Model {
     private final VersionedAddressBook versionedAddressBook;
     private final UserPrefs userPrefs;
     private final FilteredList<Person> filteredPersons;
+    private final FilteredList<Event> filteredEvents;
     private final SimpleObjectProperty<Person> selectedPerson = new SimpleObjectProperty<>();
+    private final SimpleObjectProperty<Event> selectedEvent = new SimpleObjectProperty<>();
 
     /**
      * Initializes a ModelManager with the given addressBook and userPrefs.
@@ -42,6 +46,8 @@ public ModelManager(ReadOnlyAddressBook addressBook, ReadOnlyUserPrefs userPrefs
         this.userPrefs = new UserPrefs(userPrefs);
         filteredPersons = new FilteredList<>(versionedAddressBook.getPersonList());
         filteredPersons.addListener(this::ensureSelectedPersonIsValid);
+        filteredEvents = new FilteredList<>(versionedAddressBook.getEventList());
+        filteredEvents.addListener(this::ensureSelectedEventIsValid);
     }
 
     public ModelManager() {
@@ -119,6 +125,30 @@ public void setPerson(Person target, Person editedPerson) {
         versionedAddressBook.setPerson(target, editedPerson);
     }
 
+    @Override
+    public boolean hasEvent(Event event) {
+        requireNonNull(event);
+        return versionedAddressBook.hasEvent(event);
+    }
+
+    @Override
+    public void deleteEvent(Event target) {
+        versionedAddressBook.removeEvent(target);
+    }
+
+    @Override
+    public void addEvent(Event event) {
+        versionedAddressBook.addEvent(event);
+        updateFilteredEventList(PREDICATE_SHOW_ALL_EVENTS);
+    }
+
+    @Override
+    public void setEvent(Event target, Event editedEvent) {
+        requireAllNonNull(target, editedEvent);
+
+        versionedAddressBook.setEvent(target, editedEvent);
+    }
+
     //=========== Filtered Person List Accessors =============================================================
 
     /**
@@ -136,6 +166,23 @@ public void updateFilteredPersonList(Predicate<Person> predicate) {
         filteredPersons.setPredicate(predicate);
     }
 
+    //=========== Filtered Event List Accessors =============================================================
+
+    /**
+     * Returns an unmodifiable view of the list of {@code Event} backed by the internal list of
+     * {@code versionedAddressBook}
+     */
+    @Override
+    public ObservableList<Event> getFilteredEventList() {
+        return filteredEvents;
+    }
+
+    @Override
+    public void updateFilteredEventList(Predicate<Event> predicate) {
+        requireNonNull(predicate);
+        filteredEvents.setPredicate(predicate);
+    }
+
     //=========== Undo/Redo =================================================================================
 
     @Override
@@ -229,7 +276,60 @@ public boolean equals(Object obj) {
         return versionedAddressBook.equals(other.versionedAddressBook)
                 && userPrefs.equals(other.userPrefs)
                 && filteredPersons.equals(other.filteredPersons)
-                && Objects.equals(selectedPerson.get(), other.selectedPerson.get());
+                && filteredEvents.equals(other.filteredEvents)
+                && Objects.equals(selectedPerson.get(), other.selectedPerson.get())
+                && Objects.equals(selectedEvent.get(), other.selectedEvent.get());
+    }
+
+    //=========== Selected event ===========================================================================
+
+    @Override
+    public ReadOnlyProperty<Event> selectedEventProperty() {
+        return selectedEvent;
     }
 
+    @Override
+    public Event getSelectedEvent() {
+        return selectedEvent.getValue();
+    }
+
+    @Override
+    public void setSelectedEvent(Event event) {
+        if (event != null && !filteredEvents.contains(event)) {
+            throw new EventNotFoundException();
+        }
+        selectedEvent.setValue(event);
+    }
+
+    /**
+     * Ensures {@code selectedEvent} is a valid event in {@code filteredEvents}.
+     */
+    private void ensureSelectedEventIsValid(ListChangeListener.Change<? extends Event> change) {
+        while (change.next()) {
+            if (selectedEvent.getValue() == null) {
+                // null is always a valid selected event, so we do not need to check that it is valid anymore.
+                return;
+            }
+
+            boolean wasSelectedEventReplaced = change.wasReplaced() && change.getAddedSize() == change.getRemovedSize()
+                    && change.getRemoved().contains(selectedEvent.getValue());
+            if (wasSelectedEventReplaced) {
+                // Update selectedEvent to its new value.
+                int index = change.getRemoved().indexOf(selectedEvent.getValue());
+                selectedEvent.setValue(change.getAddedSubList().get(index));
+                continue;
+            }
+
+            boolean wasSelectedEventRemoved = change.getRemoved().stream()
+                    .anyMatch(removedEvent -> selectedEvent.getValue().isSameEvent(removedEvent));
+            if (wasSelectedEventRemoved) {
+                // Select the event that came before it in the list,
+                // or clear the selection if there is no such event.
+                selectedEvent.setValue(change.getFrom() > 0 ? change.getList().get(change.getFrom() - 1) : null);
+            }
+        }
+    }
+
+
 }
+
diff --git a/src/main/java/seedu/address/model/ReadOnlyAddressBook.java b/src/main/java/seedu/address/model/ReadOnlyAddressBook.java
index 6a301434b33b..4d1c4cc74893 100644
--- a/src/main/java/seedu/address/model/ReadOnlyAddressBook.java
+++ b/src/main/java/seedu/address/model/ReadOnlyAddressBook.java
@@ -2,6 +2,7 @@
 
 import javafx.beans.Observable;
 import javafx.collections.ObservableList;
+import seedu.address.model.event.Event;
 import seedu.address.model.person.Person;
 
 /**
@@ -15,4 +16,11 @@ public interface ReadOnlyAddressBook extends Observable {
      */
     ObservableList<Person> getPersonList();
 
+    /**
+     * Returns an unmodifiable view of the events list.
+     * This list will not contain any duplicate events.
+     */
+    ObservableList<Event> getEventList();
+
+
 }
diff --git a/src/main/java/seedu/address/model/event/Event.java b/src/main/java/seedu/address/model/event/Event.java
index 7e6f51c15817..505de9c0ff79 100644
--- a/src/main/java/seedu/address/model/event/Event.java
+++ b/src/main/java/seedu/address/model/event/Event.java
@@ -2,14 +2,19 @@
 
 import static seedu.address.commons.util.CollectionUtil.requireAllNonNull;
 
+import java.util.Collections;
+import java.util.HashSet;
 import java.util.Objects;
+import java.util.Set;
+
+import seedu.address.model.person.Person;
 
 /**
  * Represents an event in the event list.
  * Guarantees: details are present and not null, field values are validated, immutable.
  */
 public class Event {
-
+    //identity
     private final Name name;
     private final Venue venue;
     private final DateTime startDateTime;
@@ -17,6 +22,7 @@ public class Event {
     private final DateTime endDateTime;
     private final Description description;
     private final Label label;
+    private final Set<Person> persons = new HashSet<>();
 
     /**
      * Every field must be present and not null.
@@ -32,6 +38,21 @@ public Event(Name name, Description description, Venue venue, DateTime startDate
         this.label = label;
     }
 
+    /**
+     * Every field must be present and not null.
+     */
+    public Event(Name name, Description description, Venue venue, DateTime startDateTime, DateTime endDateTime,
+                 Label label, Set<Person> persons) {
+        requireAllNonNull(name, description, venue, startDateTime, endDateTime, label);
+        this.name = name;
+        this.description = description;
+        this.venue = venue;
+        this.startDateTime = startDateTime;
+        this.endDateTime = endDateTime;
+        this.label = label;
+        this.persons.addAll(persons);
+    }
+
     public Name getName() {
         return name;
     }
@@ -56,6 +77,14 @@ public DateTime getEndDateTime() {
         return endDateTime;
     }
 
+    /**
+     * Returns an immutable person set, which throws {@code UnsupportedOperationException}
+     * if modification is attempted.
+     */
+    public Set<Person> getPersons() {
+        return Collections.unmodifiableSet(persons);
+    }
+
     /**
      * Returns true if both event of the same name have at least one other identity field that is the same.
      * This defines a weaker notion of equality between two events.
diff --git a/src/main/java/seedu/address/model/event/UniqueEventList.java b/src/main/java/seedu/address/model/event/UniqueEventList.java
new file mode 100644
index 000000000000..02e9cbe1ec7c
--- /dev/null
+++ b/src/main/java/seedu/address/model/event/UniqueEventList.java
@@ -0,0 +1,138 @@
+package seedu.address.model.event;
+
+import static java.util.Objects.requireNonNull;
+import static seedu.address.commons.util.CollectionUtil.requireAllNonNull;
+
+import java.util.Iterator;
+import java.util.List;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import seedu.address.model.event.exceptions.DuplicateEventException;
+import seedu.address.model.event.exceptions.EventNotFoundException;
+
+/**
+ * A list of events that enforces uniqueness between its elements and does not allow nulls.
+ * An event is considered unique by comparing using {@code Event#isSameEvent(Event)}. As such, adding and updating of
+ * events uses Event#isSameEvent(Event) for equality so as to ensure that the event being added or updated is
+ * unique in terms of identity in the UniqueEventList. However, the removal of an event uses Event#equals(Object) so
+ * as to ensure that the event with exactly the same fields will be removed.
+ *
+ * Supports a minimal set of list operations.
+ *
+ * @see Event#isSameEvent(Event)
+ */
+public class UniqueEventList implements Iterable<Event> {
+
+    private final ObservableList<Event> internalList = FXCollections.observableArrayList();
+    private final ObservableList<Event> internalUnmodifiableList =
+            FXCollections.unmodifiableObservableList(internalList);
+
+    /**
+     * Returns true if the list contains an equivalent event as the given argument.
+     */
+    public boolean contains(Event toCheck) {
+        requireNonNull(toCheck);
+        return internalList.stream().anyMatch(toCheck::isSameEvent);
+    }
+
+    /**
+     * Adds an event to the list.
+     * The event must not already exist in the list.
+     */
+    public void add(Event toAdd) {
+        requireNonNull(toAdd);
+        if (contains(toAdd)) {
+            throw new DuplicateEventException();
+        }
+        internalList.add(toAdd);
+    }
+
+    /**
+     * Replaces the event {@code target} in the list with {@code editedEvent}.
+     * {@code target} must exist in the list.
+     * The event identity of {@code editedPerson} must not be the same as another existing person in the list.
+     */
+    public void setEvent(Event target, Event editedEvent) {
+        requireAllNonNull(target, editedEvent);
+
+        int index = internalList.indexOf(target);
+        if (index == -1) {
+            throw new EventNotFoundException();
+        }
+
+        if (!target.isSameEvent(editedEvent) && contains(editedEvent)) {
+            throw new EventNotFoundException();
+        }
+
+        internalList.set(index, editedEvent);
+    }
+
+    /**
+     * Removes the equivalent event from the list.
+     * The event must exist in the list.
+     */
+    public void remove(Event toRemove) {
+        requireNonNull(toRemove);
+        if (!internalList.remove(toRemove)) {
+            throw new EventNotFoundException();
+        }
+    }
+
+    public void setEvents(UniqueEventList replacement) {
+        requireNonNull(replacement);
+        internalList.setAll(replacement.internalList);
+    }
+
+    /**
+     * Replaces the contents of this list with {@code events}.
+     * {@code persons} must not contain duplicate events.
+     */
+    public void setEvents(List<Event> events) {
+        requireAllNonNull(events);
+        if (!eventsAreUnique(events)) {
+            throw new EventNotFoundException();
+        }
+
+        internalList.setAll(events);
+    }
+
+    /**
+     * Returns the backing list as an unmodifiable {@code ObservableList}.
+     */
+    public ObservableList<Event> asUnmodifiableObservableList() {
+        return internalUnmodifiableList;
+    }
+
+    @Override
+    public Iterator<Event> iterator() {
+        return internalList.iterator();
+    }
+
+    @Override
+    public boolean equals(Object other) {
+        return other == this // short circuit if same object
+                || (other instanceof UniqueEventList // instanceof handles nulls
+                && internalList.equals(((UniqueEventList) other).internalList));
+    }
+
+    @Override
+    public int hashCode() {
+        return internalList.hashCode();
+    }
+
+    /**
+     * Returns true if {@code events} contains only unique events.
+     */
+    private boolean eventsAreUnique(List<Event> events) {
+        for (int i = 0; i < events.size() - 1; i++) {
+            for (int j = i + 1; j < events.size(); j++) {
+                if (events.get(i).isSameEvent(events.get(j))) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+
diff --git a/src/main/java/seedu/address/model/event/exceptions/DuplicateEventException.java b/src/main/java/seedu/address/model/event/exceptions/DuplicateEventException.java
new file mode 100644
index 000000000000..42ab9bed894f
--- /dev/null
+++ b/src/main/java/seedu/address/model/event/exceptions/DuplicateEventException.java
@@ -0,0 +1,11 @@
+package seedu.address.model.event.exceptions;
+
+/**
+ * Signals that the operation will result in duplicate Events (Events are considered duplicates if they have the same
+ * identity).
+ */
+public class DuplicateEventException extends RuntimeException {
+    public DuplicateEventException() {
+        super("Operation would result in duplicate events");
+    }
+}
diff --git a/src/main/java/seedu/address/model/event/exceptions/EventNotFoundException.java b/src/main/java/seedu/address/model/event/exceptions/EventNotFoundException.java
new file mode 100644
index 000000000000..5117db006eaa
--- /dev/null
+++ b/src/main/java/seedu/address/model/event/exceptions/EventNotFoundException.java
@@ -0,0 +1,6 @@
+package seedu.address.model.event.exceptions;
+
+/**
+ * Signals that the operation is unable to find the specified event.
+ */
+public class EventNotFoundException extends RuntimeException {}
diff --git a/src/test/java/seedu/address/logic/commands/AddCommandTest.java b/src/test/java/seedu/address/logic/commands/AddCommandTest.java
index f120a897779b..6a52daf7fc57 100644
--- a/src/test/java/seedu/address/logic/commands/AddCommandTest.java
+++ b/src/test/java/seedu/address/logic/commands/AddCommandTest.java
@@ -23,6 +23,7 @@
 import seedu.address.model.Model;
 import seedu.address.model.ReadOnlyAddressBook;
 import seedu.address.model.ReadOnlyUserPrefs;
+import seedu.address.model.event.Event;
 import seedu.address.model.person.Person;
 import seedu.address.testutil.PersonBuilder;
 
@@ -201,6 +202,52 @@ public Person getSelectedPerson() {
         public void setSelectedPerson(Person person) {
             throw new AssertionError("This method should not be called.");
         }
+
+        @Override
+        public void addEvent(Event event) {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public boolean hasEvent(Event event) {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public void deleteEvent(Event event) {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public void setEvent(Event target, Event editedPerson) {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public ObservableList<Event> getFilteredEventList() {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public void updateFilteredEventList(Predicate<Event> predicate) {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public ReadOnlyProperty<Event> selectedEventProperty() {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public Event getSelectedEvent() {
+            throw new AssertionError("This method should not be called.");
+        }
+
+        @Override
+        public void setSelectedEvent(Event event) {
+            throw new AssertionError("This method should not be called.");
+        }
+
     }
 
     /**
diff --git a/src/test/java/seedu/address/model/AddressBookTest.java b/src/test/java/seedu/address/model/AddressBookTest.java
index 433147e1534a..3ebceb7924df 100644
--- a/src/test/java/seedu/address/model/AddressBookTest.java
+++ b/src/test/java/seedu/address/model/AddressBookTest.java
@@ -21,6 +21,7 @@
 import javafx.beans.property.SimpleIntegerProperty;
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
+import seedu.address.model.event.Event;
 import seedu.address.model.person.Person;
 import seedu.address.model.person.exceptions.DuplicatePersonException;
 import seedu.address.testutil.PersonBuilder;
@@ -117,11 +118,17 @@ public void removeListener_withInvalidationListener_listenerRemoved() {
      */
     private static class AddressBookStub implements ReadOnlyAddressBook {
         private final ObservableList<Person> persons = FXCollections.observableArrayList();
+        private final ObservableList<Event> events = FXCollections.observableArrayList();
 
         AddressBookStub(Collection<Person> persons) {
             this.persons.setAll(persons);
         }
 
+        @Override
+        public ObservableList<Event> getEventList() {
+            return events;
+        }
+
         @Override
         public ObservableList<Person> getPersonList() {
             return persons;