Removes all notification callbacks for the given notification type

@param string $notification_type One of the constants defined in NotificationType
508602
public function clearNotificationListeners($notification_type)
    {
        if (!NotificationType::isNotificationTypeValid($notification_type)) {
            $this->_logger->log(Logger::ERROR, "Invalid notification type.");
            $this->_errorHandler->handleError(new InvalidNotificationTypeException('Invalid notification type.'));
            return;
        }

        $this->_notifications[$notification_type] = [];
        $this->_logger->log(Logger::INFO, "All callbacks for notification type '{$notification_type}' have been removed.");
    }
1160894
public function clear($type = 'notifications')
    {
        $builder = ($type === 'alerts') ? $this->getAlerts() : $this->getNotifications();

        return $this->makeModel()
                        ->getModel()
                        ->read()
                        ->getModel()
                        ->newQuery()
                        ->whereIn('stack_id', $builder->pluck('id'))->delete();
    }
585794
public function setNotificationEmail($notificationEmail)
    {
        if (!empty($notificationEmail) && ctype_print($notificationEmail)) {
            $this->notificationEmail = trim($notificationEmail);
        }

        return $this;
    }
863285
public function deleteService( $type )
	{
		$this->_notifyListeners( 'deleteService.before', $type );

		if( isset( $this->_services[$type] ) ) {
			unset( $this->_services[$type] );
			$this->_modified = true;
		}

		$this->_notifyListeners( 'deleteService.after', $type );
	}
360106
public void removeAllListeners(RESTRequest request, ObjectName source_objName, JSONConverter converter) {
        NotificationTargetInformation nti = toNotificationTargetInformation(request, source_objName.getCanonicalName());

        //Get the corresponding List for the given ObjectName
        List<ServerNotification> notifications = serverNotifications.get(nti);

        if (notifications == null) {
            throw ErrorHelper.createRESTHandlerJsonException(new ListenerNotFoundException("There are no listeners registered for ObjectName: " + source_objName.getCanonicalName()),
                                                             converter,
                                                             APIConstants.STATUS_BAD_REQUEST);
        }

        Iterator<ServerNotification> notificationsIter = notifications.iterator();
        while (notificationsIter.hasNext()) {
            ServerNotification currentRegistration = notificationsIter.next();

            if (nti.getRoutingInformation() == null) {
                //Remove from MBeanServer               
                MBeanServerHelper.removeServerNotification(source_objName, //no need to make another ObjectName
                                                           currentRegistration.listener,
                                                           (NotificationFilter) getObject(currentRegistration.filter, null, converter),
                                                           getObject(currentRegistration.handback, null, converter),
                                                           converter);
            } else {
                // Remove the notification listener from the Target-Client Manager through EventAdmin
                MBeanRoutedNotificationHelper helper = MBeanRoutedNotificationHelper.getMBeanRoutedNotificationHelper();
                helper.removeRoutedServerNotificationListener(nti,
                                                              currentRegistration.listener,
                                                              (NotificationFilter) getObject(currentRegistration.filter, null, converter),
                                                              getObject(currentRegistration.handback, null, converter),
                                                              converter);
            }
            //Remove from local list (through iterator)
            notificationsIter.remove();

            //Clean up library
            removeObject(currentRegistration.filter);
            removeObject(currentRegistration.handback);
        }
    }
1256273
func (s *NotificationConfiguration) SetNotificationType(v string) *NotificationConfiguration {
	s.NotificationType = &v
	return s
}
897862
protected function isValidNotificationType(string $notificationType): void
    {
        $allowedNotificationType = $this->getAllowedNotificationType();
        if (!\in_array($notificationType, $allowedNotificationType, true)) {
            throw new InvalidTypeException(sprintf(
                'notificationType must be either "%s".',
                implode(', ', $allowedNotificationType)
            ));
        }
    }
749710
public synchronized void removeObserver(final String notification, final ApptentiveNotificationObserver observer) {
		final ApptentiveNotificationObserverList list = findObserverList(notification);
		if (list != null) {
			list.removeObserver(observer);
		}
	}
1274967
protected function cleanup_import($notification) {
        $this->status = false;
        import_cleanup($this->importcode);
        $this->gradebookerrors[] = $notification;
    }
263691
def self_service_notification_type=(type)
      validate_notifications_supported

      # HACK: Until jamf fixes bugs, you can only set notifications
      # :off or :ssvc_only. If you want :ssvc_and_nctr, you must
      # check the checkbox in the web-UI.
      if @self_service_data_config[:notifications_supported] == :ssvc_only && type != :ssvc_only
        raise "JAMF BUG: Until Jamf fixes API bugs in #{self.class}, you can only set Self Service notifications to :ssvc_only. Use the WebUI to activate Notification Center notifications"
      end

      raise JSS::InvalidDataError, "type must be one of: :#{NOTIFICATION_TYPES.keys.join ', :'}" unless NOTIFICATION_TYPES.key? type

      @self_service_notification_type = type
      @need_to_update = true
    end
1047737
public function remove($resolverType)
    {
        $resolverType = Arr::wrap($resolverType);

        foreach ($resolverType as $type) {
            unset($this->resolvers[$type]);
        }
    }
482177
@Override
	public void clearCache() {
		entityCache.clearCache(CommerceNotificationAttachmentImpl.class);

		finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}
1182625
public function removeCustomType($type)
    {
        if (!$this->hasCustomType($type)) {
            throw PlatformException::customTypeDoesNotExist($type);
        }

        unset($this->customTypes[array_search($type, $this->customTypes)]);
    }
164465
public void setNotificationType(NotificationType notificationType) {
        addField(ConfigureNodeFields.notification_type, FormField.Type.list_single);
        setAnswer(ConfigureNodeFields.notification_type.getFieldName(), getListSingle(notificationType.toString()));
    }
450580
func (s *SetIdentityHeadersInNotificationsEnabledInput) SetNotificationType(v string) *SetIdentityHeadersInNotificationsEnabledInput {
	s.NotificationType = &v
	return s
}
486300
public static void removeMBeanRegistrationListener(MBeanServerConnection pServer,NotificationListener pListener) {
        try {
            pServer.removeNotificationListener(JmxUtil.getMBeanServerDelegateName(), pListener);
        } catch (ListenerNotFoundException e) {
            // We silently ignore listeners not found, they might have been deregistered previously
        } catch (InstanceNotFoundException e) {
            throw new IllegalStateException("Cannot find " + getMBeanServerDelegateName() + " in server " + pServer,e);
        } catch (IOException e) {
            throw new IllegalStateException("IOException while registering notification listener for " + getMBeanServerDelegateName(),e);
        }

    }
1016153
func (s *NotificationConfig) SetNotificationType(v string) *NotificationConfig {
	s.NotificationType = &v
	return s
}