class NotifyItem {

    /**
     * Notify platform id
     */
    private List<String> platformIds;

    /**
     * If enabled notify.
     */
    private boolean enabled = true;

    /**
     * Notify item, see {@link NotifyItemEnum}
     */
    private String type;

    /**
     * Alarm threshold.
     */
    private int threshold;

    /**
     * Alarm interval, time unit（s）
     */
    private int interval = 120;

    /**
     * Cluster notify limit.
     */
    private int clusterLimit = 1;

    /**
     * Receivers, split by, If NotifyPlatform.receivers have a value, they will be overwritten by the thread pool alarm
     */
    private String receivers;

    public static List<NotifyItem> mergeAllNotifyItems(List<NotifyItem> source) {
        // update notify items
        if (CollectionUtils.isEmpty(source)) {
            return getAllNotifyItems();
        } else {
            val configuredTypes = source.stream().map(NotifyItem::getType).collect(toList());
            val defaultItems = getAllNotifyItems().stream()
                    .filter(t -> !StringUtil.containsIgnoreCase(t.getType(), configuredTypes))
                    .collect(Collectors.toList());
            source.addAll(defaultItems);
            return source;
        }
    }

    public static List<NotifyItem> getAllNotifyItems() {<FILL_FUNCTION_BODY>}

    public static List<NotifyItem> getSimpleNotifyItems() {
        NotifyItem changeNotify = new NotifyItem();
        changeNotify.setType(NotifyItemEnum.CHANGE.getValue());
        changeNotify.setInterval(1);

        NotifyItem livenessNotify = new NotifyItem();
        livenessNotify.setType(NotifyItemEnum.LIVENESS.getValue());
        livenessNotify.setThreshold(70);

        NotifyItem capacityNotify = new NotifyItem();
        capacityNotify.setType(NotifyItemEnum.CAPACITY.getValue());
        capacityNotify.setThreshold(70);

        List<NotifyItem> notifyItems = new ArrayList<>(3);
        notifyItems.add(livenessNotify);
        notifyItems.add(changeNotify);
        notifyItems.add(capacityNotify);

        return notifyItems;
    }
}

        NotifyItem rejectNotify = new NotifyItem();
        rejectNotify.setType(NotifyItemEnum.REJECT.getValue());
        rejectNotify.setThreshold(10);

        NotifyItem runTimeoutNotify = new NotifyItem();
        runTimeoutNotify.setType(NotifyItemEnum.RUN_TIMEOUT.getValue());
        runTimeoutNotify.setThreshold(10);

        NotifyItem queueTimeoutNotify = new NotifyItem();
        queueTimeoutNotify.setType(NotifyItemEnum.QUEUE_TIMEOUT.getValue());
        queueTimeoutNotify.setThreshold(10);

        List<NotifyItem> notifyItems = new ArrayList<>(6);
        notifyItems.addAll(getSimpleNotifyItems());
        notifyItems.add(rejectNotify);
        notifyItems.add(runTimeoutNotify);
        notifyItems.add(queueTimeoutNotify);

        return notifyItems;
    
<no_super_class>