@deprecated

@param int|null

@return array|bool
556192
public function lists($id = null)
    {
        if ($id !== null) {
            $this->setId($id);
        }

        return $this->getList();
    }
1311185
private function _last(callable $callback = null)
    {
        $values = $this->getValues();
        if ($callback){
            foreach(array_reverse($values) as $key => $value){
                if ($callback($value, $key)){
                    return $value;
                }
            }
        }
        else{
            return empty($values) ? null : $values[count($values)-1];
        }
        return null;
    }
634419
protected function castToArray($value, bool $nullable = true)
    {
        if (null === $value) {
            return $nullable ? null : [];
        }

        if (!\is_array($value)) {
            return '' === $value ? [] : [$value];
        }

        return $value;
    }
692420
public function get($key = null)
    {
        trigger_error(__METHOD__.' is deprecated.', E_USER_DEPRECATED);

        if (0 === func_num_args()) {
            return $this->data();
        } else {
            return $this->data($key);
        }
    }
228301
public static function isNumeric($array = null) {
		if (empty($array)) {
			return null;
		}
		if ($array === range(0, count($array) - 1)) {
			return true;
		}
		$numeric = true;
		$keys = array_keys($array);
		$count = count($keys);

		for ($i = 0; $i < $count; $i++) {
			if (!is_numeric($array[$keys[$i]])) {
				$numeric = false;
				break;
			}
		}
		return $numeric;
	}
546145
public static function debugFromArray($input = null)
    {
        //====================================================================//
        // Safety Check
        if (is_null($input) || !self::isValid($input)) {
            return null;
        }
        //====================================================================//
        // return Encoded CheckSum
        return self::getDebug($input);
    }
522978
public static function array_type(&$arr=null) {
		if (! \is_array($arr) || ! \count($arr)) {
			return false;
		}

		$keys = \array_keys($arr);
		if (\range(0, \count($keys) - 1) === $keys) {
			return 'sequential';
		}
		elseif (\count($keys) === \count(\array_filter($keys, 'is_numeric'))) {
			return 'indexed';
		}
		else {
			return 'associative';
		}
	}
1292428
function cast($obj=NULL) {
		if (!$obj)
			$obj=$this;
		return array_map(
			function($row) {
				return $row['value'];
			},
			$obj->fields+$obj->adhoc
		);
	}
234643
@Deprecated
    public Pattern getPattern() {
        if (patterns != null && !patterns.isEmpty()) {
            return patterns.get(0);
        } else {
            return null;
        }
    }
242728
public function toArray()
    {
        $returnValue = parent::toArray();
        //$returnValue['ca'] = "deprecated";
        $returnValue['contextId'] = $this->contextIdentifier;
        $returnValue['contextLabel'] = $this->contextLabel;
        $returnValue['variableIdentifier'] = $this->identifier;
        

        return (array) $returnValue;
    }
868001
protected function _basicTypeCast($value)
    {
        deprecationWarning(
            'Using Type::_basicTypeCast() is deprecated. ' .
            "The '{$this->_name}' type needs to be updated to implement `TypeInterface`."
        );
        if ($value === null) {
            return null;
        }
        if (!empty(static::$_basicTypes[$this->_name])) {
            $typeInfo = static::$_basicTypes[$this->_name];
            if (isset($typeInfo['callback'])) {
                return $typeInfo['callback']($value);
            }
        }

        return $value;
    }
943245
protected function _decodeValue()
    {
        switch ($this->_token) {
        case self::DATUM:
            $result  = $this->_tokenValue;
            $this->_getNextToken();
            return($result);
                break;
        case self::LBRACE:
            return($this->_decodeObject());
                break;
        case self::LBRACKET:
            return($this->_decodeArray());
                break;
        default:
            return null;
                break;
        }
    }
250210
public function columns($cols = null)
    {
        deprecationWarning(
            'ValuesExpression::columns() is deprecated. ' .
            'Use ValuesExpression::setColumns()/getColumns() instead.'
        );
        if ($cols !== null) {
            return $this->setColumns($cols);
        }

        return $this->getColumns();
    }
1266661
protected function _getListFieldsNullVal() {
		$result = [];
		$schema = $this->schema();
		$data = array_filter(
			$schema,
			function ($v, $k) {

				return isset($v['null']) && $v['null'] === true;
			},
			ARRAY_FILTER_USE_BOTH
		);
		if (!empty($data)) {
			$result = array_keys($data);
		}

		return $result;
	}
1119711
public static function fromArray($input = null)
    {
        //====================================================================//
        // Safety Check
        if (is_null($input) || !self::isValid($input)) {
            return null;
        }
        //====================================================================//
        // return Encoded CheckSum
        return self::getEncoded($input);
    }
39536
private function normalize($value)
    {
        // Normalize array values
        if (is_array($value)) {
            foreach ($value as &$subValue) {
                $subValue = $this->normalize($subValue);
            }

            return $value;
        }

        // Don't normalize non-string value
        if (!is_string($value)) {
            return $value;
        }

        // Normalize true boolean value
        if ($this->compareValues($value, ['true', 'on', 'yes'])) {
            return true;
        }

        // Normalize false boolean value
        if ($this->compareValues($value, ['false', 'off', 'no', 'none'])) {
            return false;
        }

        // Normalize null value
        if ($this->compareValues($value, ['null'])) {
            return;
        }

        // Normalize numeric value
        if (is_numeric($value)) {
            $numericValue = $value + 0;

            if ((is_int($numericValue) && (int) $value === $numericValue)
                || (is_float($numericValue) && (float) $value === $numericValue)
            ) {
                $value = $numericValue;
            }
        }

        return $value;
    }
760128
public function toArray() : ?array
    {
        if (null === $this->stmt || false === $this->stmt) {
            return null;
        }
        return $this->stmt->toArray();
    }