[[@doctodo method_description:registerUnarchiveAuditEvent]].

@param array $base [[@doctodo param_description:base]] [optional]

@return [[@doctodo return_type:registerUnarchiveAuditEvent]] [[@doctodo return_description:registerUnarchiveAuditEvent]]
352697
public function registerUnarchiveAuditEvent($base = [])
    {
        if ($this->owner->getBehavior('Auditable') === null) {
            return false;
        }
        if (!isset($base['class'])) {
            $base['class'] = $this->unarchiveEventClass;
        }

        return $this->registerArchivableAuditEvent($base);
    }
913796
public function setChannels($channels)
	{
		if ( ! is_numeric($channels) || $channels < 1)
		{
			throw new \InvalidArgumentException('Wrong audio channels value.');
		}
		
		$this->audioChannels = $channels;
		
		return $this;
	}
665746
public function build(): RemoveInstrumentationBreakpointRequest
	{
		$instance = new RemoveInstrumentationBreakpointRequest();
		if ($this->eventName === null) {
			throw new BuilderException('Property [eventName] is required.');
		}
		$instance->eventName = $this->eventName;
		return $instance;
	}
1347912
public function merge(array $base, array $merge): array
    {
        $options = array_merge($base, $merge); // Base should include all existing.
        $options = array_intersect_key($options, $this->App->Config->§default_options);

        foreach ($this->App->Config->§default_options as $_key => $_default_option_value) {
            if (!isset($options[$_key])) {
                $options[$_key] = $_default_option_value;
            } elseif (!$this->App->Config->§specs['§is_pro'] && in_array($_key, $this->App->Config->§pro_option_keys, true)) {
                $options[$_key] = $_default_option_value;
            } elseif (!$this->App->Config->§specs['§is_elite'] && in_array($_key, $this->App->Config->§elite_option_keys, true)) {
                $options[$_key] = $_default_option_value;
            } else {
                settype($options[$_key], gettype($_default_option_value));
            }
        } // unset($_key, $_default_option_value);

        return $options;
    }
172722
public function setBase($base)
    {
        // Typecast base to string in case we've been given
        // an instance of the distinguished name object.
        $base = (string) $base;

        // If the base DN isn't null we'll try to explode it.
        $base = Utilities::explodeDn($base, false) ?: [];

        // Remove the count key from the exploded distinguished name.
        unset($base['count']);

        foreach ($base as $key => $rdn) {
            // We'll break the RDN into pieces
            $pieces = explode('=', $rdn) ?: [];

            // If there's exactly 2 pieces, then we can work with it.
            if (count($pieces) === 2) {
                $attribute = ucfirst(strtolower($pieces[0]));

                $method = 'add'.$attribute;

                if (method_exists($this, $method)) {
                    // We see what type of RDN it is and add each accordingly.
                    call_user_func_array([$this, $method], [$pieces[1]]);
                }
            }
        }

        return $this;
    }
1361756
public function onEventRegistration(Event $event)
    {
        $this->unitOfWork->publishEvent($event, $this->eventBus);

        return $this->unitOfWork->invokeEventRegistrationListeners($event);
    }
1068777
public static function randomStr( $base )
	{
		$result = "";

		if ( is_int( $base ) )
			for ( $i = 0; $i < $base; $i++ )
				$result .= static::$randomCharMap[random_int( 0, count( static::$randomCharMap ) )];
		else
			for ( $i = 0; $i < strlen( $base ); $i++ )
				$result .= static::randomChar( $base[$i] );

		return $result;
	}
1159993
protected function registerArchivableAuditEvent($base = [])
    {
        if ($this->owner->getBehavior('Auditable') === null) {
            return false;
        }
        $eventLog = $base;
        if (!isset($eventLog['class'])) {
            return false;
        }
        $eventLog['directObject'] = $this->owner;
        $eventLog['indirectObject'] = $this->owner->indirectObject;

        return $this->owner->registerAuditEvent($eventLog);
    }
979889
public static function buildBasedIntRegex($base)
    {
        assert(2 <= $base && $base <= 16);
        $regex = '/(?i:[0-';
        if ($base <= 10) {
            $regex .= (string)$base-1;
        } else {
            $regex .= '9a-' . strtolower(dechex($base-1));
        }
        $regex .= '])+/';
        return $regex;
    }
342997
public function registration()
    {
        /**
         * @var Config $settings
         */
        if ($this->getDI() === null) {
            throw new DiNotFoundException("DI can't be found.");
        }

        $creator = new Creator($this->di);

        foreach ($this->services as $name => $settings) {
            $creator->setService($settings);
            $service = $creator->injection();

            if ($service !== null) {
                $call = $settings->get('shared') ? 'setShared' : 'set';
                $this->getDI()->$call($name, $service);
            }
        }
        $this->services = null;
    }
543848
protected function getClassFileName($base = false)
    {
        return ($base ? $this->getTableFileName(null, array('%entity%' => 'Base'.DIRECTORY_SEPARATOR.'Base'.$this->getModelName())) : $this->getTableFileName());
    }
498870
private function registerBase()
    {
        $this['request'] = function () {
            return Request::createFromGlobals();
        };

        if (!empty($this['config']['cache']) && $this['config']['cache'] instanceof CacheInterface) {
            $this['cache'] = $this['config']['cache'];
        } else {
            $this['cache'] = function () {
                return $this->registerCache(
                    is_array($this['config']['cache']) ? $this['config']['cache'] : ['driver' => null]
                );
            };
        }

        $this['ticket'] = function () {
            return new Ticket(
                $this['config']['app_id'],
                isset($this['config']['ticket']) && isset($this['config']['ticket']['cache']) ? $this['config']['ticket']['cache'] : $this['cache']
            );
        };

        $this['access_token'] = function () {
            return new AccessToken(
                $this['config'],
                $this['ticket'],
                $this['cache']
            );
        };

        $this['open_platform'] = function () {
            return new OpenPlatform(
                $this['access_token']
            );
        };
    }
1025422
public function get($serviceId)
    {
        if (!$this->has($serviceId)) {
            throw DiServiceNotFound::createFromServiceId($serviceId);
        }

        if (!isset($this->services[$serviceId])) {
            $this->services[$serviceId] = $this->getServiceFromFactory($serviceId);
        }

        return $this->services[$serviceId];
    }
373571
public function setRolesAtBase($rolesAtBase)
    {
        $allowedValues = $this->getRolesAtBaseAllowableValues();
        if (!is_null($rolesAtBase) && array_diff($rolesAtBase, $allowedValues)) {
            throw new \InvalidArgumentException(
                sprintf(
                    "Invalid value for 'rolesAtBase', must be one of '%s'",
                    implode("', '", $allowedValues)
                )
            );
        }
        $this->container['rolesAtBase'] = $rolesAtBase;

        return $this;
    }
510729
public function createSuccess(array $events = []): EventCollection
    {
        $suiteClass = $this->suiteClass;
        $suiteClass::current()->assert($this->successConfig);

        return new EventSequence($events, $this->callVerifierFactory);
    }
1333056
public function addAudio($source = null, $attributes = [])
    {
        $validKeys = [
            'url',
            'secure_url',
            'type',
        ];

        $this->audioProperties[] = [
            $source,
            $this->cleanProperties($attributes, $validKeys),
        ];

        return $this;
    }
809917
public function actionAudio()
    {
        $model = new UploaderAudioForm();
        $model->load(Yii::$app->getRequest()->getBodyParams(), '');
        if ($model->save() != false) {
            Yii::$app->getResponse()->setStatusCode(201);
            return $model;
        } elseif (!$model->hasErrors()) {
            throw new ServerErrorHttpException('Failed to create the object for unknown reason.');
        }
        return $model;
    }