Detach this event from the associated Calendar

@return $this
499555
public function detach()
    {
        $this->calendar->getEvents()->removeEvent($this);
        $this->calendar = null;

        return $this;
    }
210089
protected function dispatchConfigurationEvents(): self
    {
        foreach ($this->iterationsEvents as $event) {
            if (!($this->loopCount % $event['count'])) {
                $this->dispatchEvent($event['name']);
            }
        }

        return $this;
    }
1018260
public function detach()
    {
        $stream = $this->stream;

        $this->stream = null;
        $this->isPipe = false;
        $this->size = null;

        $this->metaData = null;

        $this->seekable = false;
        $this->writable = false;
        $this->readable = false;

        return $stream;
    }
846199
public function remove()
    {
        unset($this->_nodes[$this->_pointer]);
        $this->_nodes = array_values($this->_nodes);
        return $this;
    }
1074892
public function sort()
	{
		usort($this->allEvents, function ($event1, $event2) {
			if ($event1->getStartDate() == $event2->getStartDate()) {
				return $event1->getId() < $event2->getId() ? -1 : 1;
			}

			return $event1->getStartDate() < $event2->getStartDate() ? -1 : 1;
		});

		return $this;
	}
1058769
public final function detach()
   {
       $stream = null;
       if ($this->stream) {
           $this->close();
           $stream = $this->stream;
           $this->stream = null;
       }
       return $stream;
   }
984865
function() {
			var events	= this.events;
			if (!events) { return this; }

			var tag		= this.tag,
				prefix	= '',
				method	= 'removeEventListener';


			// Round and round we go...
			if (!tag.removeEventListener) {
				prefix = 'on';
				method = 'detachEvent';
			}

			tag[method](prefix + 'error', events.failed);
			tag[method](prefix + 'load', events.loaded);
			tag[method](prefix + 'readystatechange', events.state);

			delete this.events;
			return this;
		}
494872
public function detach(string $event, $callback){
        if(isset($this->listeners[$event])){
            return $this->listeners[$event]->remove($callback);
        }
        return false;
    }
404967
public function unbind()
    {
        if ($this->isBinded()) {
            $this->getSocket()->unbind($this->dsn);
            $this->dsn = null;
        }

        return $this;
    }
1289374
public function tick()
    {
        if ($this->ticksUntilUnload !== null) {
            --$this->ticksUntilUnload;
            if ($this->ticksUntilUnload < 1) {
                $this->unloadDoctrineEntities();
                $this->ticksUntilUnload = $this->unloadDoctrineEveryTick;
            }
        }

        return $this;
    }
651591
protected function offAll(string $eventName): self
    {
        $hasEvent = $this->listeners[$eventName] ?? false;
        if ($hasEvent) {
            unset($this->listeners[$eventName], $this->sorted[$eventName]);
        }

        return $this;
    }
540524
public function detachShared(SharedEventManagerInterface $events)
    {
        if ($events->detach($this->listener,'Zend\Mvc\Application')) {
            $this->listener = null;
        }
        return $this;
    }
108684
public function detach()
    {
        $this->_offset = $this->_current = 0;
        $this->_seekable = true;

        foreach ($this->_streams as $stream) {
            $stream->detach();
        }

        $this->_streams = [];
    }
194311
public function uncork()
    {
        $this->_corked = false;

        while ($call = array_shift($this->_queue)) {
            call_user_func_array(array($this,'trigger'), $call);
        }

        return $this;
    }
993420
public function detach($event, $callback){
        $events = is_array($event) ? $event : array($event);
        $listeners = $this->getOption(self::OPTION_LISTENERS);
        foreach ($events as $event) {
            $eventObject = is_object($event) ? $event : new GenericEvent($event);
            $listeners = $this->removeListener($listeners, $eventObject, $callback);
        }
        $this->setOption(self::OPTION_LISTENERS, $listeners);
    }
661034
public function delete(){

        foreach($this->_items as $key => $item){
            if($item->exists()){
                $deleted = $item->delete();
                if($deleted){
                   unset($this->_items[$key]);
                }
            }
        }

        return $this;

    }
290800
public function discard()
    {
        if ($this->state->isInitialized()) {
            $this->call($this->state->isCAS() ? 'UNWATCH' : 'DISCARD');

            $this->reset();
            $this->state->flag(MultiExecState::DISCARDED);
        }

        return $this;
    }