Final Class Yiisoft\Db\Schema\Column\ArrayColumn

                public function __construct(
    ?string $type = null,
    private bool $autoIncrement = false,
    private ?string $check = null,
    private ?string $comment = null,
    private bool $computed = false,
    private ?string $dbType = null,
    private ?string $extra = null,
    private bool $primaryKey = false,
    private ?string $name = null,
    private ?bool $notNull = null,
    private ?ForeignKey $reference = null,
    private ?int $scale = null,
    private ?int $size = null,
    private bool $unique = false,
    private bool $unsigned = false,
    mixed ...$args,
) {
    $this->type = $type ?? static::DEFAULT_TYPE;
    if (array_key_exists('defaultValue', $args)) {
        $this->defaultValue = $args['defaultValue'];
        unset($args['defaultValue']);
    }
    /** @psalm-var array<string, mixed> $args */
    foreach ($args as $property => $value) {
        if (property_exists($this, $property)) {
            $this->$property = $value;
        }
    }
}

            

                public function autoIncrement(bool $autoIncrement = true): static
{
    $this->autoIncrement = $autoIncrement;
    return $this;
}

            

                public function check(?string $check): static
{
    $this->check = $check;
    return $this;
}

            

                public function column(?ColumnInterface $column): static
{
    $this->column = $column;
    return $this;
}

            

                public function comment(?string $comment): static
{
    $this->comment = $comment;
    return $this;
}

            

                public function computed(bool $computed = true): static
{
    $this->computed = $computed;
    return $this;
}

            

                public function dbType(?string $dbType): static
{
    $this->dbType = $dbType;
    return $this;
}

            

                public function dbTypecast(mixed $value): ?ExpressionInterface
{
    if ($value === null || $value instanceof ExpressionInterface) {
        return $value;
    }
    return new ArrayValue($value, $this);
}

            

                public function defaultValue(mixed $defaultValue): static
{
    $this->defaultValue = $defaultValue;
    return $this;
}

            

                public function dimension(int $dimension): static
{
    $this->dimension = $dimension;
    return $this;
}

            

                public function extra(?string $extra): static
{
    $this->extra = $extra;
    return $this;
}

            

                public function getCheck(): ?string
{
    return $this->check;
}

            

                public function getColumn(): ?ColumnInterface
{
    return $this->column;
}

            

                public function getComment(): ?string
{
    return $this->comment;
}

            

                public function getDbType(): ?string
{
    return $this->dbType;
}

            

                public function getDefaultValue(): mixed
{
    return $this->defaultValue ?? null;
}

            

                public function getDimension(): int
{
    return $this->dimension;
}

            

                public function getExtra(): ?string
{
    return $this->extra;
}

            

                public function getName(): ?string
{
    return $this->name;
}

            

                public function getReference(): ?ForeignKey
{
    return $this->reference;
}

            

                public function getScale(): ?int
{
    return $this->scale;
}

            

                public function getSize(): ?int
{
    return $this->size;
}

            

                public function getType(): string
{
    return $this->type;
}

            

                public function hasDefaultValue(): bool
{
    return property_exists($this, 'defaultValue');
}

            

                public function isAutoIncrement(): bool
{
    return $this->autoIncrement;
}

            

                public function isComputed(): bool
{
    return $this->computed;
}

            

                public function isNotNull(): ?bool
{
    return $this->notNull;
}

            

                public function isPrimaryKey(): bool
{
    return $this->primaryKey;
}

            

                public function isUnique(): bool
{
    return $this->unique;
}

            

                public function isUnsigned(): bool
{
    return $this->unsigned;
}

            

                public function notNull(?bool $notNull = true): static
{
    $this->notNull = $notNull;
    return $this;
}

            

                public function null(): static
{
    $this->notNull = false;
    return $this;
}

            

                public function primaryKey(bool $primaryKey = true): static
{
    $this->primaryKey = $primaryKey;
    return $this;
}

            

                public function reference(?ForeignKey $reference): static
{
    $this->reference = $reference;
    return $this;
}

            

                public function scale(?int $scale): static
{
    $this->scale = $scale;
    return $this;
}

            

                public function size(?int $size): static
{
    $this->size = $size;
    return $this;
}

            

                protected function throwWrongTypeException(string $type): never
{
    throw new InvalidArgumentException("Wrong $type value for $this->type column.");
}

            

                public function type(string $type): static
{
    $this->type = $type;
    return $this;
}

            

                public function unique(bool $unique = true): static
{
    $this->unique = $unique;
    return $this;
}

            

                public function unsigned(bool $unsigned = true): static
{
    $this->unsigned = $unsigned;
    return $this;
}

            

                public function withName(?string $name): static
{
    $new = clone $this;
    $new->name = $name;
    return $new;
}