<?php
/**
 * InfoModel
 *
 * PHP version 8.1
 *
 * @package  OpenAPI\Client
 * @author   OpenAPI Generator team
 * @link     https://openapi-generator.tech
 */

/**
 * Lethean Blockchain API
 *
 * OpenAPI for Lethean Blockchain
 *
 * The version of the OpenAPI document: 6.0.1
 * @generated Generated by: https://openapi-generator.tech
 * Generator version: 7.16.0
 */

/**
 * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
 * https://openapi-generator.tech
 * Do not edit the class manually.
 */

namespace OpenAPI\Client\Model;

use ArrayAccess;
use JsonSerializable;
use InvalidArgumentException;
use ReturnTypeWillChange;
use OpenAPI\Client\ObjectSerializer;

/**
 * InfoModel Class Doc Comment
 *
 * @package  OpenAPI\Client
 * @author   OpenAPI Generator team
 * @link     https://openapi-generator.tech
 * @implements ArrayAccess<string, mixed>
 */
class InfoModel implements ModelInterface, ArrayAccess, JsonSerializable
{
    public const DISCRIMINATOR = null;

    /**
      * The original name of the model.
      *
      * @var string
      */
    protected static string $openAPIModelName = 'InfoModel';

    /**
      * Array of property to type mappings. Used for (de)serialization
      *
      * @var array<string, string>
      */
    protected static array $openAPITypes = [
        'height' => 'int',
        'tx_count' => 'int',
        'tx_pool_size' => 'int',
        'alt_blocks_count' => 'int',
        'outgoing_connections_count' => 'int',
        'incoming_connections_count' => 'int',
        'synchronized_connections_count' => 'int',
        'white_peerlist_size' => 'int',
        'grey_peerlist_size' => 'int',
        'current_blocks_median' => 'int',
        'alias_count' => 'int',
        'current_max_allowed_block_size' => 'int',
        'daemon_network_state' => 'string',
        'synchronization_start_height' => 'int',
        'max_net_seen_height' => 'int',
        'mi' => '\OpenAPI\Client\Model\MaintainersInfoModel',
        'pos_allowed' => 'bool',
        'pos_difficulty' => 'string',
        'pow_difficulty' => 'int',
        'default_fee' => 'int',
        'minimum_fee' => 'int',
        'is_hardfork_active' => 'bool[]',
        'net_time_delta_median' => 'int',
        'current_network_hashrate_50' => 'int',
        'current_network_hashrate_350' => 'int',
        'seconds_for_10_blocks' => 'int',
        'seconds_for_30_blocks' => 'int',
        'transactions_cnt_per_day' => 'int[]',
        'transactions_volume_per_day' => 'int[]',
        'last_pos_timestamp' => 'int',
        'last_pow_timestamp' => 'int',
        'total_coins' => 'string',
        'last_block_size' => 'int',
        'tx_count_in_last_block' => 'int',
        'pos_sequence_factor' => 'float',
        'pow_sequence_factor' => 'float',
        'block_reward' => 'int',
        'last_block_total_reward' => 'int',
        'pos_diff_total_coins_rate' => 'int',
        'last_block_timestamp' => 'int',
        'last_block_hash' => 'string',
        'pos_block_ts_shift_vs_actual' => 'int',
        'outs_stat' => 'array<string,int>',
        'performance_data' => '\OpenAPI\Client\Model\PerformanceModel',
        'offers_count' => 'int',
        'expiration_median_timestamp' => 'int'
    ];

    /**
      * Array of property to format mappings. Used for (de)serialization
      *
      * @var array<string, string|null>
      */
    protected static array $openAPIFormats = [
        'height' => null,
        'tx_count' => null,
        'tx_pool_size' => null,
        'alt_blocks_count' => null,
        'outgoing_connections_count' => null,
        'incoming_connections_count' => null,
        'synchronized_connections_count' => null,
        'white_peerlist_size' => null,
        'grey_peerlist_size' => null,
        'current_blocks_median' => null,
        'alias_count' => null,
        'current_max_allowed_block_size' => null,
        'daemon_network_state' => null,
        'synchronization_start_height' => null,
        'max_net_seen_height' => null,
        'mi' => null,
        'pos_allowed' => null,
        'pos_difficulty' => null,
        'pow_difficulty' => null,
        'default_fee' => null,
        'minimum_fee' => null,
        'is_hardfork_active' => null,
        'net_time_delta_median' => 'int64',
        'current_network_hashrate_50' => null,
        'current_network_hashrate_350' => null,
        'seconds_for_10_blocks' => null,
        'seconds_for_30_blocks' => null,
        'transactions_cnt_per_day' => null,
        'transactions_volume_per_day' => null,
        'last_pos_timestamp' => null,
        'last_pow_timestamp' => null,
        'total_coins' => null,
        'last_block_size' => null,
        'tx_count_in_last_block' => null,
        'pos_sequence_factor' => 'double',
        'pow_sequence_factor' => 'double',
        'block_reward' => null,
        'last_block_total_reward' => null,
        'pos_diff_total_coins_rate' => null,
        'last_block_timestamp' => null,
        'last_block_hash' => null,
        'pos_block_ts_shift_vs_actual' => 'int64',
        'outs_stat' => null,
        'performance_data' => null,
        'offers_count' => null,
        'expiration_median_timestamp' => null
    ];

    /**
      * Array of nullable properties. Used for (de)serialization
      *
      * @var array<string, bool>
      */
    protected static array $openAPINullables = [
        'height' => false,
        'tx_count' => false,
        'tx_pool_size' => false,
        'alt_blocks_count' => false,
        'outgoing_connections_count' => false,
        'incoming_connections_count' => false,
        'synchronized_connections_count' => false,
        'white_peerlist_size' => false,
        'grey_peerlist_size' => false,
        'current_blocks_median' => false,
        'alias_count' => false,
        'current_max_allowed_block_size' => false,
        'daemon_network_state' => false,
        'synchronization_start_height' => false,
        'max_net_seen_height' => false,
        'mi' => false,
        'pos_allowed' => false,
        'pos_difficulty' => false,
        'pow_difficulty' => false,
        'default_fee' => false,
        'minimum_fee' => false,
        'is_hardfork_active' => false,
        'net_time_delta_median' => false,
        'current_network_hashrate_50' => false,
        'current_network_hashrate_350' => false,
        'seconds_for_10_blocks' => false,
        'seconds_for_30_blocks' => false,
        'transactions_cnt_per_day' => false,
        'transactions_volume_per_day' => false,
        'last_pos_timestamp' => false,
        'last_pow_timestamp' => false,
        'total_coins' => false,
        'last_block_size' => false,
        'tx_count_in_last_block' => false,
        'pos_sequence_factor' => false,
        'pow_sequence_factor' => false,
        'block_reward' => false,
        'last_block_total_reward' => false,
        'pos_diff_total_coins_rate' => false,
        'last_block_timestamp' => false,
        'last_block_hash' => false,
        'pos_block_ts_shift_vs_actual' => false,
        'outs_stat' => false,
        'performance_data' => false,
        'offers_count' => false,
        'expiration_median_timestamp' => false
    ];

    /**
      * If a nullable field gets set to null, insert it here
      *
      * @var array<string, bool>
      */
    protected array $openAPINullablesSetToNull = [];

    /**
     * Array of property to type mappings. Used for (de)serialization
     *
     * @return array<string, string>
     */
    public static function openAPITypes(): array
    {
        return self::$openAPITypes;
    }

    /**
     * Array of property to format mappings. Used for (de)serialization
     *
     * @return array<string, string>
     */
    public static function openAPIFormats(): array
    {
        return self::$openAPIFormats;
    }

    /**
     * Array of nullable properties
     *
     * @return array<string, bool>
     */
    protected static function openAPINullables(): array
    {
        return self::$openAPINullables;
    }

    /**
     * Array of nullable field names deliberately set to null
     *
     * @return array<string, bool>
     */
    private function getOpenAPINullablesSetToNull(): array
    {
        return $this->openAPINullablesSetToNull;
    }

    /**
     * Setter - Array of nullable field names deliberately set to null
     *
     * @param array<string, bool> $openAPINullablesSetToNull
     */
    private function setOpenAPINullablesSetToNull(array $openAPINullablesSetToNull): void
    {
        $this->openAPINullablesSetToNull = $openAPINullablesSetToNull;
    }

    /**
     * Checks if a property is nullable
     *
     * @param string $property
     * @return bool
     */
    public static function isNullable(string $property): bool
    {
        return self::openAPINullables()[$property] ?? false;
    }

    /**
     * Checks if a nullable property is set to null.
     *
     * @param string $property
     * @return bool
     */
    public function isNullableSetToNull(string $property): bool
    {
        return in_array($property, $this->getOpenAPINullablesSetToNull(), true);
    }

    /**
     * Array of attributes where the key is the local name,
     * and the value is the original name
     *
     * @var array<string, string>
     */
    protected static array $attributeMap = [
        'height' => 'height',
        'tx_count' => 'tx_count',
        'tx_pool_size' => 'tx_pool_size',
        'alt_blocks_count' => 'alt_blocks_count',
        'outgoing_connections_count' => 'outgoing_connections_count',
        'incoming_connections_count' => 'incoming_connections_count',
        'synchronized_connections_count' => 'synchronized_connections_count',
        'white_peerlist_size' => 'white_peerlist_size',
        'grey_peerlist_size' => 'grey_peerlist_size',
        'current_blocks_median' => 'current_blocks_median',
        'alias_count' => 'alias_count',
        'current_max_allowed_block_size' => 'current_max_allowed_block_size',
        'daemon_network_state' => 'daemon_network_state',
        'synchronization_start_height' => 'synchronization_start_height',
        'max_net_seen_height' => 'max_net_seen_height',
        'mi' => 'mi',
        'pos_allowed' => 'pos_allowed',
        'pos_difficulty' => 'pos_difficulty',
        'pow_difficulty' => 'pow_difficulty',
        'default_fee' => 'default_fee',
        'minimum_fee' => 'minimum_fee',
        'is_hardfork_active' => 'is_hardfork_active',
        'net_time_delta_median' => 'net_time_delta_median',
        'current_network_hashrate_50' => 'current_network_hashrate_50',
        'current_network_hashrate_350' => 'current_network_hashrate_350',
        'seconds_for_10_blocks' => 'seconds_for_10_blocks',
        'seconds_for_30_blocks' => 'seconds_for_30_blocks',
        'transactions_cnt_per_day' => 'transactions_cnt_per_day',
        'transactions_volume_per_day' => 'transactions_volume_per_day',
        'last_pos_timestamp' => 'last_pos_timestamp',
        'last_pow_timestamp' => 'last_pow_timestamp',
        'total_coins' => 'total_coins',
        'last_block_size' => 'last_block_size',
        'tx_count_in_last_block' => 'tx_count_in_last_block',
        'pos_sequence_factor' => 'pos_sequence_factor',
        'pow_sequence_factor' => 'pow_sequence_factor',
        'block_reward' => 'block_reward',
        'last_block_total_reward' => 'last_block_total_reward',
        'pos_diff_total_coins_rate' => 'pos_diff_total_coins_rate',
        'last_block_timestamp' => 'last_block_timestamp',
        'last_block_hash' => 'last_block_hash',
        'pos_block_ts_shift_vs_actual' => 'pos_block_ts_shift_vs_actual',
        'outs_stat' => 'outs_stat',
        'performance_data' => 'performance_data',
        'offers_count' => 'offers_count',
        'expiration_median_timestamp' => 'expiration_median_timestamp'
    ];

    /**
     * Array of attributes to setter functions (for deserialization of responses)
     *
     * @var array<string, string>
     */
    protected static array $setters = [
        'height' => 'setHeight',
        'tx_count' => 'setTxCount',
        'tx_pool_size' => 'setTxPoolSize',
        'alt_blocks_count' => 'setAltBlocksCount',
        'outgoing_connections_count' => 'setOutgoingConnectionsCount',
        'incoming_connections_count' => 'setIncomingConnectionsCount',
        'synchronized_connections_count' => 'setSynchronizedConnectionsCount',
        'white_peerlist_size' => 'setWhitePeerlistSize',
        'grey_peerlist_size' => 'setGreyPeerlistSize',
        'current_blocks_median' => 'setCurrentBlocksMedian',
        'alias_count' => 'setAliasCount',
        'current_max_allowed_block_size' => 'setCurrentMaxAllowedBlockSize',
        'daemon_network_state' => 'setDaemonNetworkState',
        'synchronization_start_height' => 'setSynchronizationStartHeight',
        'max_net_seen_height' => 'setMaxNetSeenHeight',
        'mi' => 'setMi',
        'pos_allowed' => 'setPosAllowed',
        'pos_difficulty' => 'setPosDifficulty',
        'pow_difficulty' => 'setPowDifficulty',
        'default_fee' => 'setDefaultFee',
        'minimum_fee' => 'setMinimumFee',
        'is_hardfork_active' => 'setIsHardforkActive',
        'net_time_delta_median' => 'setNetTimeDeltaMedian',
        'current_network_hashrate_50' => 'setCurrentNetworkHashrate50',
        'current_network_hashrate_350' => 'setCurrentNetworkHashrate350',
        'seconds_for_10_blocks' => 'setSecondsFor10Blocks',
        'seconds_for_30_blocks' => 'setSecondsFor30Blocks',
        'transactions_cnt_per_day' => 'setTransactionsCntPerDay',
        'transactions_volume_per_day' => 'setTransactionsVolumePerDay',
        'last_pos_timestamp' => 'setLastPosTimestamp',
        'last_pow_timestamp' => 'setLastPowTimestamp',
        'total_coins' => 'setTotalCoins',
        'last_block_size' => 'setLastBlockSize',
        'tx_count_in_last_block' => 'setTxCountInLastBlock',
        'pos_sequence_factor' => 'setPosSequenceFactor',
        'pow_sequence_factor' => 'setPowSequenceFactor',
        'block_reward' => 'setBlockReward',
        'last_block_total_reward' => 'setLastBlockTotalReward',
        'pos_diff_total_coins_rate' => 'setPosDiffTotalCoinsRate',
        'last_block_timestamp' => 'setLastBlockTimestamp',
        'last_block_hash' => 'setLastBlockHash',
        'pos_block_ts_shift_vs_actual' => 'setPosBlockTsShiftVsActual',
        'outs_stat' => 'setOutsStat',
        'performance_data' => 'setPerformanceData',
        'offers_count' => 'setOffersCount',
        'expiration_median_timestamp' => 'setExpirationMedianTimestamp'
    ];

    /**
     * Array of attributes to getter functions (for serialization of requests)
     *
     * @var array<string, string>
     */
    protected static array $getters = [
        'height' => 'getHeight',
        'tx_count' => 'getTxCount',
        'tx_pool_size' => 'getTxPoolSize',
        'alt_blocks_count' => 'getAltBlocksCount',
        'outgoing_connections_count' => 'getOutgoingConnectionsCount',
        'incoming_connections_count' => 'getIncomingConnectionsCount',
        'synchronized_connections_count' => 'getSynchronizedConnectionsCount',
        'white_peerlist_size' => 'getWhitePeerlistSize',
        'grey_peerlist_size' => 'getGreyPeerlistSize',
        'current_blocks_median' => 'getCurrentBlocksMedian',
        'alias_count' => 'getAliasCount',
        'current_max_allowed_block_size' => 'getCurrentMaxAllowedBlockSize',
        'daemon_network_state' => 'getDaemonNetworkState',
        'synchronization_start_height' => 'getSynchronizationStartHeight',
        'max_net_seen_height' => 'getMaxNetSeenHeight',
        'mi' => 'getMi',
        'pos_allowed' => 'getPosAllowed',
        'pos_difficulty' => 'getPosDifficulty',
        'pow_difficulty' => 'getPowDifficulty',
        'default_fee' => 'getDefaultFee',
        'minimum_fee' => 'getMinimumFee',
        'is_hardfork_active' => 'getIsHardforkActive',
        'net_time_delta_median' => 'getNetTimeDeltaMedian',
        'current_network_hashrate_50' => 'getCurrentNetworkHashrate50',
        'current_network_hashrate_350' => 'getCurrentNetworkHashrate350',
        'seconds_for_10_blocks' => 'getSecondsFor10Blocks',
        'seconds_for_30_blocks' => 'getSecondsFor30Blocks',
        'transactions_cnt_per_day' => 'getTransactionsCntPerDay',
        'transactions_volume_per_day' => 'getTransactionsVolumePerDay',
        'last_pos_timestamp' => 'getLastPosTimestamp',
        'last_pow_timestamp' => 'getLastPowTimestamp',
        'total_coins' => 'getTotalCoins',
        'last_block_size' => 'getLastBlockSize',
        'tx_count_in_last_block' => 'getTxCountInLastBlock',
        'pos_sequence_factor' => 'getPosSequenceFactor',
        'pow_sequence_factor' => 'getPowSequenceFactor',
        'block_reward' => 'getBlockReward',
        'last_block_total_reward' => 'getLastBlockTotalReward',
        'pos_diff_total_coins_rate' => 'getPosDiffTotalCoinsRate',
        'last_block_timestamp' => 'getLastBlockTimestamp',
        'last_block_hash' => 'getLastBlockHash',
        'pos_block_ts_shift_vs_actual' => 'getPosBlockTsShiftVsActual',
        'outs_stat' => 'getOutsStat',
        'performance_data' => 'getPerformanceData',
        'offers_count' => 'getOffersCount',
        'expiration_median_timestamp' => 'getExpirationMedianTimestamp'
    ];

    /**
     * Array of attributes where the key is the local name,
     * and the value is the original name
     *
     * @return array<string, string>
     */
    public static function attributeMap(): array
    {
        return self::$attributeMap;
    }

    /**
     * Array of attributes to setter functions (for deserialization of responses)
     *
     * @return array<string, string>
     */
    public static function setters(): array
    {
        return self::$setters;
    }

    /**
     * Array of attributes to getter functions (for serialization of requests)
     *
     * @return array<string, string>
     */
    public static function getters(): array
    {
        return self::$getters;
    }

    /**
     * The original name of the model.
     *
     * @return string
     */
    public function getModelName(): string
    {
        return self::$openAPIModelName;
    }


    /**
     * Associative array for storing property values
     *
     * @var array
     */
    protected array $container = [];

    /**
     * Constructor
     *
     * @param array $data Associated array of property values initializing the model
     */
    public function __construct(?array $data = null)
    {
        $this->setIfExists('height', $data ?? [], null);
        $this->setIfExists('tx_count', $data ?? [], null);
        $this->setIfExists('tx_pool_size', $data ?? [], null);
        $this->setIfExists('alt_blocks_count', $data ?? [], null);
        $this->setIfExists('outgoing_connections_count', $data ?? [], null);
        $this->setIfExists('incoming_connections_count', $data ?? [], null);
        $this->setIfExists('synchronized_connections_count', $data ?? [], null);
        $this->setIfExists('white_peerlist_size', $data ?? [], null);
        $this->setIfExists('grey_peerlist_size', $data ?? [], null);
        $this->setIfExists('current_blocks_median', $data ?? [], null);
        $this->setIfExists('alias_count', $data ?? [], null);
        $this->setIfExists('current_max_allowed_block_size', $data ?? [], null);
        $this->setIfExists('daemon_network_state', $data ?? [], null);
        $this->setIfExists('synchronization_start_height', $data ?? [], null);
        $this->setIfExists('max_net_seen_height', $data ?? [], null);
        $this->setIfExists('mi', $data ?? [], null);
        $this->setIfExists('pos_allowed', $data ?? [], null);
        $this->setIfExists('pos_difficulty', $data ?? [], null);
        $this->setIfExists('pow_difficulty', $data ?? [], null);
        $this->setIfExists('default_fee', $data ?? [], null);
        $this->setIfExists('minimum_fee', $data ?? [], null);
        $this->setIfExists('is_hardfork_active', $data ?? [], null);
        $this->setIfExists('net_time_delta_median', $data ?? [], null);
        $this->setIfExists('current_network_hashrate_50', $data ?? [], null);
        $this->setIfExists('current_network_hashrate_350', $data ?? [], null);
        $this->setIfExists('seconds_for_10_blocks', $data ?? [], null);
        $this->setIfExists('seconds_for_30_blocks', $data ?? [], null);
        $this->setIfExists('transactions_cnt_per_day', $data ?? [], null);
        $this->setIfExists('transactions_volume_per_day', $data ?? [], null);
        $this->setIfExists('last_pos_timestamp', $data ?? [], null);
        $this->setIfExists('last_pow_timestamp', $data ?? [], null);
        $this->setIfExists('total_coins', $data ?? [], null);
        $this->setIfExists('last_block_size', $data ?? [], null);
        $this->setIfExists('tx_count_in_last_block', $data ?? [], null);
        $this->setIfExists('pos_sequence_factor', $data ?? [], null);
        $this->setIfExists('pow_sequence_factor', $data ?? [], null);
        $this->setIfExists('block_reward', $data ?? [], null);
        $this->setIfExists('last_block_total_reward', $data ?? [], null);
        $this->setIfExists('pos_diff_total_coins_rate', $data ?? [], null);
        $this->setIfExists('last_block_timestamp', $data ?? [], null);
        $this->setIfExists('last_block_hash', $data ?? [], null);
        $this->setIfExists('pos_block_ts_shift_vs_actual', $data ?? [], null);
        $this->setIfExists('outs_stat', $data ?? [], null);
        $this->setIfExists('performance_data', $data ?? [], null);
        $this->setIfExists('offers_count', $data ?? [], null);
        $this->setIfExists('expiration_median_timestamp', $data ?? [], null);
    }

    /**
    * Sets $this->container[$variableName] to the given data or to the given default Value; if $variableName
    * is nullable and its value is set to null in the $fields array, then mark it as "set to null" in the
    * $this->openAPINullablesSetToNull array
    *
    * @param string $variableName
    * @param array  $fields
    * @param mixed  $defaultValue
    */
    private function setIfExists(string $variableName, array $fields, mixed $defaultValue): void
    {
        if (self::isNullable($variableName) && array_key_exists($variableName, $fields) && is_null($fields[$variableName])) {
            $this->openAPINullablesSetToNull[] = $variableName;
        }

        $this->container[$variableName] = $fields[$variableName] ?? $defaultValue;
    }

    /**
     * Show all the invalid properties with reasons.
     *
     * @return string[] invalid properties with reasons
     */
    public function listInvalidProperties(): array
    {
        $invalidProperties = [];

        return $invalidProperties;
    }

    /**
     * Validate all the properties in the model
     * return true if all passed
     *
     * @return bool True if all properties are valid
     */
    public function valid(): bool
    {
        return count($this->listInvalidProperties()) === 0;
    }


    /**
     * Gets height
     *
     * @return int|null
     */
    public function getHeight(): ?int
    {
        return $this->container['height'];
    }

    /**
     * Sets height
     *
     * @param int|null $height height
     *
     * @return $this
     */
    public function setHeight(?int $height): static
    {
        if (is_null($height)) {
            throw new InvalidArgumentException('non-nullable height cannot be null');
        }
        $this->container['height'] = $height;

        return $this;
    }

    /**
     * Gets tx_count
     *
     * @return int|null
     */
    public function getTxCount(): ?int
    {
        return $this->container['tx_count'];
    }

    /**
     * Sets tx_count
     *
     * @param int|null $tx_count tx_count
     *
     * @return $this
     */
    public function setTxCount(?int $tx_count): static
    {
        if (is_null($tx_count)) {
            throw new InvalidArgumentException('non-nullable tx_count cannot be null');
        }
        $this->container['tx_count'] = $tx_count;

        return $this;
    }

    /**
     * Gets tx_pool_size
     *
     * @return int|null
     */
    public function getTxPoolSize(): ?int
    {
        return $this->container['tx_pool_size'];
    }

    /**
     * Sets tx_pool_size
     *
     * @param int|null $tx_pool_size tx_pool_size
     *
     * @return $this
     */
    public function setTxPoolSize(?int $tx_pool_size): static
    {
        if (is_null($tx_pool_size)) {
            throw new InvalidArgumentException('non-nullable tx_pool_size cannot be null');
        }
        $this->container['tx_pool_size'] = $tx_pool_size;

        return $this;
    }

    /**
     * Gets alt_blocks_count
     *
     * @return int|null
     */
    public function getAltBlocksCount(): ?int
    {
        return $this->container['alt_blocks_count'];
    }

    /**
     * Sets alt_blocks_count
     *
     * @param int|null $alt_blocks_count alt_blocks_count
     *
     * @return $this
     */
    public function setAltBlocksCount(?int $alt_blocks_count): static
    {
        if (is_null($alt_blocks_count)) {
            throw new InvalidArgumentException('non-nullable alt_blocks_count cannot be null');
        }
        $this->container['alt_blocks_count'] = $alt_blocks_count;

        return $this;
    }

    /**
     * Gets outgoing_connections_count
     *
     * @return int|null
     */
    public function getOutgoingConnectionsCount(): ?int
    {
        return $this->container['outgoing_connections_count'];
    }

    /**
     * Sets outgoing_connections_count
     *
     * @param int|null $outgoing_connections_count outgoing_connections_count
     *
     * @return $this
     */
    public function setOutgoingConnectionsCount(?int $outgoing_connections_count): static
    {
        if (is_null($outgoing_connections_count)) {
            throw new InvalidArgumentException('non-nullable outgoing_connections_count cannot be null');
        }
        $this->container['outgoing_connections_count'] = $outgoing_connections_count;

        return $this;
    }

    /**
     * Gets incoming_connections_count
     *
     * @return int|null
     */
    public function getIncomingConnectionsCount(): ?int
    {
        return $this->container['incoming_connections_count'];
    }

    /**
     * Sets incoming_connections_count
     *
     * @param int|null $incoming_connections_count incoming_connections_count
     *
     * @return $this
     */
    public function setIncomingConnectionsCount(?int $incoming_connections_count): static
    {
        if (is_null($incoming_connections_count)) {
            throw new InvalidArgumentException('non-nullable incoming_connections_count cannot be null');
        }
        $this->container['incoming_connections_count'] = $incoming_connections_count;

        return $this;
    }

    /**
     * Gets synchronized_connections_count
     *
     * @return int|null
     */
    public function getSynchronizedConnectionsCount(): ?int
    {
        return $this->container['synchronized_connections_count'];
    }

    /**
     * Sets synchronized_connections_count
     *
     * @param int|null $synchronized_connections_count synchronized_connections_count
     *
     * @return $this
     */
    public function setSynchronizedConnectionsCount(?int $synchronized_connections_count): static
    {
        if (is_null($synchronized_connections_count)) {
            throw new InvalidArgumentException('non-nullable synchronized_connections_count cannot be null');
        }
        $this->container['synchronized_connections_count'] = $synchronized_connections_count;

        return $this;
    }

    /**
     * Gets white_peerlist_size
     *
     * @return int|null
     */
    public function getWhitePeerlistSize(): ?int
    {
        return $this->container['white_peerlist_size'];
    }

    /**
     * Sets white_peerlist_size
     *
     * @param int|null $white_peerlist_size white_peerlist_size
     *
     * @return $this
     */
    public function setWhitePeerlistSize(?int $white_peerlist_size): static
    {
        if (is_null($white_peerlist_size)) {
            throw new InvalidArgumentException('non-nullable white_peerlist_size cannot be null');
        }
        $this->container['white_peerlist_size'] = $white_peerlist_size;

        return $this;
    }

    /**
     * Gets grey_peerlist_size
     *
     * @return int|null
     */
    public function getGreyPeerlistSize(): ?int
    {
        return $this->container['grey_peerlist_size'];
    }

    /**
     * Sets grey_peerlist_size
     *
     * @param int|null $grey_peerlist_size grey_peerlist_size
     *
     * @return $this
     */
    public function setGreyPeerlistSize(?int $grey_peerlist_size): static
    {
        if (is_null($grey_peerlist_size)) {
            throw new InvalidArgumentException('non-nullable grey_peerlist_size cannot be null');
        }
        $this->container['grey_peerlist_size'] = $grey_peerlist_size;

        return $this;
    }

    /**
     * Gets current_blocks_median
     *
     * @return int|null
     */
    public function getCurrentBlocksMedian(): ?int
    {
        return $this->container['current_blocks_median'];
    }

    /**
     * Sets current_blocks_median
     *
     * @param int|null $current_blocks_median current_blocks_median
     *
     * @return $this
     */
    public function setCurrentBlocksMedian(?int $current_blocks_median): static
    {
        if (is_null($current_blocks_median)) {
            throw new InvalidArgumentException('non-nullable current_blocks_median cannot be null');
        }
        $this->container['current_blocks_median'] = $current_blocks_median;

        return $this;
    }

    /**
     * Gets alias_count
     *
     * @return int|null
     */
    public function getAliasCount(): ?int
    {
        return $this->container['alias_count'];
    }

    /**
     * Sets alias_count
     *
     * @param int|null $alias_count alias_count
     *
     * @return $this
     */
    public function setAliasCount(?int $alias_count): static
    {
        if (is_null($alias_count)) {
            throw new InvalidArgumentException('non-nullable alias_count cannot be null');
        }
        $this->container['alias_count'] = $alias_count;

        return $this;
    }

    /**
     * Gets current_max_allowed_block_size
     *
     * @return int|null
     */
    public function getCurrentMaxAllowedBlockSize(): ?int
    {
        return $this->container['current_max_allowed_block_size'];
    }

    /**
     * Sets current_max_allowed_block_size
     *
     * @param int|null $current_max_allowed_block_size current_max_allowed_block_size
     *
     * @return $this
     */
    public function setCurrentMaxAllowedBlockSize(?int $current_max_allowed_block_size): static
    {
        if (is_null($current_max_allowed_block_size)) {
            throw new InvalidArgumentException('non-nullable current_max_allowed_block_size cannot be null');
        }
        $this->container['current_max_allowed_block_size'] = $current_max_allowed_block_size;

        return $this;
    }

    /**
     * Gets daemon_network_state
     *
     * @return string|null
     */
    public function getDaemonNetworkState(): ?string
    {
        return $this->container['daemon_network_state'];
    }

    /**
     * Sets daemon_network_state
     *
     * @param string|null $daemon_network_state daemon_network_state
     *
     * @return $this
     */
    public function setDaemonNetworkState(?string $daemon_network_state): static
    {
        if (is_null($daemon_network_state)) {
            throw new InvalidArgumentException('non-nullable daemon_network_state cannot be null');
        }
        $this->container['daemon_network_state'] = $daemon_network_state;

        return $this;
    }

    /**
     * Gets synchronization_start_height
     *
     * @return int|null
     */
    public function getSynchronizationStartHeight(): ?int
    {
        return $this->container['synchronization_start_height'];
    }

    /**
     * Sets synchronization_start_height
     *
     * @param int|null $synchronization_start_height synchronization_start_height
     *
     * @return $this
     */
    public function setSynchronizationStartHeight(?int $synchronization_start_height): static
    {
        if (is_null($synchronization_start_height)) {
            throw new InvalidArgumentException('non-nullable synchronization_start_height cannot be null');
        }
        $this->container['synchronization_start_height'] = $synchronization_start_height;

        return $this;
    }

    /**
     * Gets max_net_seen_height
     *
     * @return int|null
     */
    public function getMaxNetSeenHeight(): ?int
    {
        return $this->container['max_net_seen_height'];
    }

    /**
     * Sets max_net_seen_height
     *
     * @param int|null $max_net_seen_height max_net_seen_height
     *
     * @return $this
     */
    public function setMaxNetSeenHeight(?int $max_net_seen_height): static
    {
        if (is_null($max_net_seen_height)) {
            throw new InvalidArgumentException('non-nullable max_net_seen_height cannot be null');
        }
        $this->container['max_net_seen_height'] = $max_net_seen_height;

        return $this;
    }

    /**
     * Gets mi
     *
     * @return \OpenAPI\Client\Model\MaintainersInfoModel|null
     */
    public function getMi(): ?\OpenAPI\Client\Model\MaintainersInfoModel
    {
        return $this->container['mi'];
    }

    /**
     * Sets mi
     *
     * @param \OpenAPI\Client\Model\MaintainersInfoModel|null $mi mi
     *
     * @return $this
     */
    public function setMi(?\OpenAPI\Client\Model\MaintainersInfoModel $mi): static
    {
        if (is_null($mi)) {
            throw new InvalidArgumentException('non-nullable mi cannot be null');
        }
        $this->container['mi'] = $mi;

        return $this;
    }

    /**
     * Gets pos_allowed
     *
     * @return bool|null
     */
    public function getPosAllowed(): ?bool
    {
        return $this->container['pos_allowed'];
    }

    /**
     * Sets pos_allowed
     *
     * @param bool|null $pos_allowed pos_allowed
     *
     * @return $this
     */
    public function setPosAllowed(?bool $pos_allowed): static
    {
        if (is_null($pos_allowed)) {
            throw new InvalidArgumentException('non-nullable pos_allowed cannot be null');
        }
        $this->container['pos_allowed'] = $pos_allowed;

        return $this;
    }

    /**
     * Gets pos_difficulty
     *
     * @return string|null
     */
    public function getPosDifficulty(): ?string
    {
        return $this->container['pos_difficulty'];
    }

    /**
     * Sets pos_difficulty
     *
     * @param string|null $pos_difficulty pos_difficulty
     *
     * @return $this
     */
    public function setPosDifficulty(?string $pos_difficulty): static
    {
        if (is_null($pos_difficulty)) {
            throw new InvalidArgumentException('non-nullable pos_difficulty cannot be null');
        }
        $this->container['pos_difficulty'] = $pos_difficulty;

        return $this;
    }

    /**
     * Gets pow_difficulty
     *
     * @return int|null
     */
    public function getPowDifficulty(): ?int
    {
        return $this->container['pow_difficulty'];
    }

    /**
     * Sets pow_difficulty
     *
     * @param int|null $pow_difficulty pow_difficulty
     *
     * @return $this
     */
    public function setPowDifficulty(?int $pow_difficulty): static
    {
        if (is_null($pow_difficulty)) {
            throw new InvalidArgumentException('non-nullable pow_difficulty cannot be null');
        }
        $this->container['pow_difficulty'] = $pow_difficulty;

        return $this;
    }

    /**
     * Gets default_fee
     *
     * @return int|null
     */
    public function getDefaultFee(): ?int
    {
        return $this->container['default_fee'];
    }

    /**
     * Sets default_fee
     *
     * @param int|null $default_fee default_fee
     *
     * @return $this
     */
    public function setDefaultFee(?int $default_fee): static
    {
        if (is_null($default_fee)) {
            throw new InvalidArgumentException('non-nullable default_fee cannot be null');
        }
        $this->container['default_fee'] = $default_fee;

        return $this;
    }

    /**
     * Gets minimum_fee
     *
     * @return int|null
     */
    public function getMinimumFee(): ?int
    {
        return $this->container['minimum_fee'];
    }

    /**
     * Sets minimum_fee
     *
     * @param int|null $minimum_fee minimum_fee
     *
     * @return $this
     */
    public function setMinimumFee(?int $minimum_fee): static
    {
        if (is_null($minimum_fee)) {
            throw new InvalidArgumentException('non-nullable minimum_fee cannot be null');
        }
        $this->container['minimum_fee'] = $minimum_fee;

        return $this;
    }

    /**
     * Gets is_hardfork_active
     *
     * @return bool[]|null
     */
    public function getIsHardforkActive(): ?array
    {
        return $this->container['is_hardfork_active'];
    }

    /**
     * Sets is_hardfork_active
     *
     * @param bool[]|null $is_hardfork_active is_hardfork_active
     *
     * @return $this
     */
    public function setIsHardforkActive(?array $is_hardfork_active): static
    {
        if (is_null($is_hardfork_active)) {
            throw new InvalidArgumentException('non-nullable is_hardfork_active cannot be null');
        }
        $this->container['is_hardfork_active'] = $is_hardfork_active;

        return $this;
    }

    /**
     * Gets net_time_delta_median
     *
     * @return int|null
     */
    public function getNetTimeDeltaMedian(): ?int
    {
        return $this->container['net_time_delta_median'];
    }

    /**
     * Sets net_time_delta_median
     *
     * @param int|null $net_time_delta_median net_time_delta_median
     *
     * @return $this
     */
    public function setNetTimeDeltaMedian(?int $net_time_delta_median): static
    {
        if (is_null($net_time_delta_median)) {
            throw new InvalidArgumentException('non-nullable net_time_delta_median cannot be null');
        }
        $this->container['net_time_delta_median'] = $net_time_delta_median;

        return $this;
    }

    /**
     * Gets current_network_hashrate_50
     *
     * @return int|null
     */
    public function getCurrentNetworkHashrate50(): ?int
    {
        return $this->container['current_network_hashrate_50'];
    }

    /**
     * Sets current_network_hashrate_50
     *
     * @param int|null $current_network_hashrate_50 current_network_hashrate_50
     *
     * @return $this
     */
    public function setCurrentNetworkHashrate50(?int $current_network_hashrate_50): static
    {
        if (is_null($current_network_hashrate_50)) {
            throw new InvalidArgumentException('non-nullable current_network_hashrate_50 cannot be null');
        }
        $this->container['current_network_hashrate_50'] = $current_network_hashrate_50;

        return $this;
    }

    /**
     * Gets current_network_hashrate_350
     *
     * @return int|null
     */
    public function getCurrentNetworkHashrate350(): ?int
    {
        return $this->container['current_network_hashrate_350'];
    }

    /**
     * Sets current_network_hashrate_350
     *
     * @param int|null $current_network_hashrate_350 current_network_hashrate_350
     *
     * @return $this
     */
    public function setCurrentNetworkHashrate350(?int $current_network_hashrate_350): static
    {
        if (is_null($current_network_hashrate_350)) {
            throw new InvalidArgumentException('non-nullable current_network_hashrate_350 cannot be null');
        }
        $this->container['current_network_hashrate_350'] = $current_network_hashrate_350;

        return $this;
    }

    /**
     * Gets seconds_for_10_blocks
     *
     * @return int|null
     */
    public function getSecondsFor10Blocks(): ?int
    {
        return $this->container['seconds_for_10_blocks'];
    }

    /**
     * Sets seconds_for_10_blocks
     *
     * @param int|null $seconds_for_10_blocks seconds_for_10_blocks
     *
     * @return $this
     */
    public function setSecondsFor10Blocks(?int $seconds_for_10_blocks): static
    {
        if (is_null($seconds_for_10_blocks)) {
            throw new InvalidArgumentException('non-nullable seconds_for_10_blocks cannot be null');
        }
        $this->container['seconds_for_10_blocks'] = $seconds_for_10_blocks;

        return $this;
    }

    /**
     * Gets seconds_for_30_blocks
     *
     * @return int|null
     */
    public function getSecondsFor30Blocks(): ?int
    {
        return $this->container['seconds_for_30_blocks'];
    }

    /**
     * Sets seconds_for_30_blocks
     *
     * @param int|null $seconds_for_30_blocks seconds_for_30_blocks
     *
     * @return $this
     */
    public function setSecondsFor30Blocks(?int $seconds_for_30_blocks): static
    {
        if (is_null($seconds_for_30_blocks)) {
            throw new InvalidArgumentException('non-nullable seconds_for_30_blocks cannot be null');
        }
        $this->container['seconds_for_30_blocks'] = $seconds_for_30_blocks;

        return $this;
    }

    /**
     * Gets transactions_cnt_per_day
     *
     * @return int[]|null
     */
    public function getTransactionsCntPerDay(): ?array
    {
        return $this->container['transactions_cnt_per_day'];
    }

    /**
     * Sets transactions_cnt_per_day
     *
     * @param int[]|null $transactions_cnt_per_day transactions_cnt_per_day
     *
     * @return $this
     */
    public function setTransactionsCntPerDay(?array $transactions_cnt_per_day): static
    {
        if (is_null($transactions_cnt_per_day)) {
            throw new InvalidArgumentException('non-nullable transactions_cnt_per_day cannot be null');
        }
        $this->container['transactions_cnt_per_day'] = $transactions_cnt_per_day;

        return $this;
    }

    /**
     * Gets transactions_volume_per_day
     *
     * @return int[]|null
     */
    public function getTransactionsVolumePerDay(): ?array
    {
        return $this->container['transactions_volume_per_day'];
    }

    /**
     * Sets transactions_volume_per_day
     *
     * @param int[]|null $transactions_volume_per_day transactions_volume_per_day
     *
     * @return $this
     */
    public function setTransactionsVolumePerDay(?array $transactions_volume_per_day): static
    {
        if (is_null($transactions_volume_per_day)) {
            throw new InvalidArgumentException('non-nullable transactions_volume_per_day cannot be null');
        }
        $this->container['transactions_volume_per_day'] = $transactions_volume_per_day;

        return $this;
    }

    /**
     * Gets last_pos_timestamp
     *
     * @return int|null
     */
    public function getLastPosTimestamp(): ?int
    {
        return $this->container['last_pos_timestamp'];
    }

    /**
     * Sets last_pos_timestamp
     *
     * @param int|null $last_pos_timestamp last_pos_timestamp
     *
     * @return $this
     */
    public function setLastPosTimestamp(?int $last_pos_timestamp): static
    {
        if (is_null($last_pos_timestamp)) {
            throw new InvalidArgumentException('non-nullable last_pos_timestamp cannot be null');
        }
        $this->container['last_pos_timestamp'] = $last_pos_timestamp;

        return $this;
    }

    /**
     * Gets last_pow_timestamp
     *
     * @return int|null
     */
    public function getLastPowTimestamp(): ?int
    {
        return $this->container['last_pow_timestamp'];
    }

    /**
     * Sets last_pow_timestamp
     *
     * @param int|null $last_pow_timestamp last_pow_timestamp
     *
     * @return $this
     */
    public function setLastPowTimestamp(?int $last_pow_timestamp): static
    {
        if (is_null($last_pow_timestamp)) {
            throw new InvalidArgumentException('non-nullable last_pow_timestamp cannot be null');
        }
        $this->container['last_pow_timestamp'] = $last_pow_timestamp;

        return $this;
    }

    /**
     * Gets total_coins
     *
     * @return string|null
     */
    public function getTotalCoins(): ?string
    {
        return $this->container['total_coins'];
    }

    /**
     * Sets total_coins
     *
     * @param string|null $total_coins total_coins
     *
     * @return $this
     */
    public function setTotalCoins(?string $total_coins): static
    {
        if (is_null($total_coins)) {
            throw new InvalidArgumentException('non-nullable total_coins cannot be null');
        }
        $this->container['total_coins'] = $total_coins;

        return $this;
    }

    /**
     * Gets last_block_size
     *
     * @return int|null
     */
    public function getLastBlockSize(): ?int
    {
        return $this->container['last_block_size'];
    }

    /**
     * Sets last_block_size
     *
     * @param int|null $last_block_size last_block_size
     *
     * @return $this
     */
    public function setLastBlockSize(?int $last_block_size): static
    {
        if (is_null($last_block_size)) {
            throw new InvalidArgumentException('non-nullable last_block_size cannot be null');
        }
        $this->container['last_block_size'] = $last_block_size;

        return $this;
    }

    /**
     * Gets tx_count_in_last_block
     *
     * @return int|null
     */
    public function getTxCountInLastBlock(): ?int
    {
        return $this->container['tx_count_in_last_block'];
    }

    /**
     * Sets tx_count_in_last_block
     *
     * @param int|null $tx_count_in_last_block tx_count_in_last_block
     *
     * @return $this
     */
    public function setTxCountInLastBlock(?int $tx_count_in_last_block): static
    {
        if (is_null($tx_count_in_last_block)) {
            throw new InvalidArgumentException('non-nullable tx_count_in_last_block cannot be null');
        }
        $this->container['tx_count_in_last_block'] = $tx_count_in_last_block;

        return $this;
    }

    /**
     * Gets pos_sequence_factor
     *
     * @return float|null
     */
    public function getPosSequenceFactor(): ?float
    {
        return $this->container['pos_sequence_factor'];
    }

    /**
     * Sets pos_sequence_factor
     *
     * @param float|null $pos_sequence_factor pos_sequence_factor
     *
     * @return $this
     */
    public function setPosSequenceFactor(?float $pos_sequence_factor): static
    {
        if (is_null($pos_sequence_factor)) {
            throw new InvalidArgumentException('non-nullable pos_sequence_factor cannot be null');
        }
        $this->container['pos_sequence_factor'] = $pos_sequence_factor;

        return $this;
    }

    /**
     * Gets pow_sequence_factor
     *
     * @return float|null
     */
    public function getPowSequenceFactor(): ?float
    {
        return $this->container['pow_sequence_factor'];
    }

    /**
     * Sets pow_sequence_factor
     *
     * @param float|null $pow_sequence_factor pow_sequence_factor
     *
     * @return $this
     */
    public function setPowSequenceFactor(?float $pow_sequence_factor): static
    {
        if (is_null($pow_sequence_factor)) {
            throw new InvalidArgumentException('non-nullable pow_sequence_factor cannot be null');
        }
        $this->container['pow_sequence_factor'] = $pow_sequence_factor;

        return $this;
    }

    /**
     * Gets block_reward
     *
     * @return int|null
     */
    public function getBlockReward(): ?int
    {
        return $this->container['block_reward'];
    }

    /**
     * Sets block_reward
     *
     * @param int|null $block_reward block_reward
     *
     * @return $this
     */
    public function setBlockReward(?int $block_reward): static
    {
        if (is_null($block_reward)) {
            throw new InvalidArgumentException('non-nullable block_reward cannot be null');
        }
        $this->container['block_reward'] = $block_reward;

        return $this;
    }

    /**
     * Gets last_block_total_reward
     *
     * @return int|null
     */
    public function getLastBlockTotalReward(): ?int
    {
        return $this->container['last_block_total_reward'];
    }

    /**
     * Sets last_block_total_reward
     *
     * @param int|null $last_block_total_reward last_block_total_reward
     *
     * @return $this
     */
    public function setLastBlockTotalReward(?int $last_block_total_reward): static
    {
        if (is_null($last_block_total_reward)) {
            throw new InvalidArgumentException('non-nullable last_block_total_reward cannot be null');
        }
        $this->container['last_block_total_reward'] = $last_block_total_reward;

        return $this;
    }

    /**
     * Gets pos_diff_total_coins_rate
     *
     * @return int|null
     */
    public function getPosDiffTotalCoinsRate(): ?int
    {
        return $this->container['pos_diff_total_coins_rate'];
    }

    /**
     * Sets pos_diff_total_coins_rate
     *
     * @param int|null $pos_diff_total_coins_rate pos_diff_total_coins_rate
     *
     * @return $this
     */
    public function setPosDiffTotalCoinsRate(?int $pos_diff_total_coins_rate): static
    {
        if (is_null($pos_diff_total_coins_rate)) {
            throw new InvalidArgumentException('non-nullable pos_diff_total_coins_rate cannot be null');
        }
        $this->container['pos_diff_total_coins_rate'] = $pos_diff_total_coins_rate;

        return $this;
    }

    /**
     * Gets last_block_timestamp
     *
     * @return int|null
     */
    public function getLastBlockTimestamp(): ?int
    {
        return $this->container['last_block_timestamp'];
    }

    /**
     * Sets last_block_timestamp
     *
     * @param int|null $last_block_timestamp last_block_timestamp
     *
     * @return $this
     */
    public function setLastBlockTimestamp(?int $last_block_timestamp): static
    {
        if (is_null($last_block_timestamp)) {
            throw new InvalidArgumentException('non-nullable last_block_timestamp cannot be null');
        }
        $this->container['last_block_timestamp'] = $last_block_timestamp;

        return $this;
    }

    /**
     * Gets last_block_hash
     *
     * @return string|null
     */
    public function getLastBlockHash(): ?string
    {
        return $this->container['last_block_hash'];
    }

    /**
     * Sets last_block_hash
     *
     * @param string|null $last_block_hash last_block_hash
     *
     * @return $this
     */
    public function setLastBlockHash(?string $last_block_hash): static
    {
        if (is_null($last_block_hash)) {
            throw new InvalidArgumentException('non-nullable last_block_hash cannot be null');
        }
        $this->container['last_block_hash'] = $last_block_hash;

        return $this;
    }

    /**
     * Gets pos_block_ts_shift_vs_actual
     *
     * @return int|null
     */
    public function getPosBlockTsShiftVsActual(): ?int
    {
        return $this->container['pos_block_ts_shift_vs_actual'];
    }

    /**
     * Sets pos_block_ts_shift_vs_actual
     *
     * @param int|null $pos_block_ts_shift_vs_actual pos_block_ts_shift_vs_actual
     *
     * @return $this
     */
    public function setPosBlockTsShiftVsActual(?int $pos_block_ts_shift_vs_actual): static
    {
        if (is_null($pos_block_ts_shift_vs_actual)) {
            throw new InvalidArgumentException('non-nullable pos_block_ts_shift_vs_actual cannot be null');
        }
        $this->container['pos_block_ts_shift_vs_actual'] = $pos_block_ts_shift_vs_actual;

        return $this;
    }

    /**
     * Gets outs_stat
     *
     * @return array<string,int>|null
     */
    public function getOutsStat(): ?array
    {
        return $this->container['outs_stat'];
    }

    /**
     * Sets outs_stat
     *
     * @param array<string,int>|null $outs_stat outs_stat
     *
     * @return $this
     */
    public function setOutsStat(?array $outs_stat): static
    {
        if (is_null($outs_stat)) {
            throw new InvalidArgumentException('non-nullable outs_stat cannot be null');
        }
        $this->container['outs_stat'] = $outs_stat;

        return $this;
    }

    /**
     * Gets performance_data
     *
     * @return \OpenAPI\Client\Model\PerformanceModel|null
     */
    public function getPerformanceData(): ?\OpenAPI\Client\Model\PerformanceModel
    {
        return $this->container['performance_data'];
    }

    /**
     * Sets performance_data
     *
     * @param \OpenAPI\Client\Model\PerformanceModel|null $performance_data performance_data
     *
     * @return $this
     */
    public function setPerformanceData(?\OpenAPI\Client\Model\PerformanceModel $performance_data): static
    {
        if (is_null($performance_data)) {
            throw new InvalidArgumentException('non-nullable performance_data cannot be null');
        }
        $this->container['performance_data'] = $performance_data;

        return $this;
    }

    /**
     * Gets offers_count
     *
     * @return int|null
     */
    public function getOffersCount(): ?int
    {
        return $this->container['offers_count'];
    }

    /**
     * Sets offers_count
     *
     * @param int|null $offers_count offers_count
     *
     * @return $this
     */
    public function setOffersCount(?int $offers_count): static
    {
        if (is_null($offers_count)) {
            throw new InvalidArgumentException('non-nullable offers_count cannot be null');
        }
        $this->container['offers_count'] = $offers_count;

        return $this;
    }

    /**
     * Gets expiration_median_timestamp
     *
     * @return int|null
     */
    public function getExpirationMedianTimestamp(): ?int
    {
        return $this->container['expiration_median_timestamp'];
    }

    /**
     * Sets expiration_median_timestamp
     *
     * @param int|null $expiration_median_timestamp expiration_median_timestamp
     *
     * @return $this
     */
    public function setExpirationMedianTimestamp(?int $expiration_median_timestamp): static
    {
        if (is_null($expiration_median_timestamp)) {
            throw new InvalidArgumentException('non-nullable expiration_median_timestamp cannot be null');
        }
        $this->container['expiration_median_timestamp'] = $expiration_median_timestamp;

        return $this;
    }
    /**
     * Returns true if offset exists. False otherwise.
     *
     * @param integer $offset Offset
     *
     * @return boolean
     */
    public function offsetExists(mixed $offset): bool
    {
        return isset($this->container[$offset]);
    }

    /**
     * Gets offset.
     *
     * @param integer $offset Offset
     *
     * @return mixed|null
     */
    #[ReturnTypeWillChange]
    public function offsetGet(mixed $offset): mixed
    {
        return $this->container[$offset] ?? null;
    }

    /**
     * Sets value based on offset.
     *
     * @param int|null $offset Offset
     * @param mixed    $value  Value to be set
     *
     * @return void
     */
    public function offsetSet(mixed $offset, mixed $value): void
    {
        if (is_null($offset)) {
            $this->container[] = $value;
        } else {
            $this->container[$offset] = $value;
        }
    }

    /**
     * Unsets offset.
     *
     * @param integer $offset Offset
     *
     * @return void
     */
    public function offsetUnset(mixed $offset): void
    {
        unset($this->container[$offset]);
    }

    /**
     * Serializes the object to a value that can be serialized natively by json_encode().
     * @link https://www.php.net/manual/en/jsonserializable.jsonserialize.php
     *
     * @return mixed Returns data which can be serialized by json_encode(), which is a value
     * of any type other than a resource.
     */
    #[ReturnTypeWillChange]
    public function jsonSerialize(): mixed
    {
       return ObjectSerializer::sanitizeForSerialization($this);
    }

    /**
     * Gets the string presentation of the object
     *
     * @return string
     */
    public function __toString(): string
    {
        return json_encode(
            ObjectSerializer::sanitizeForSerialization($this),
            JSON_PRETTY_PRINT
        );
    }

    /**
     * Gets a header-safe presentation of the object
     *
     * @return string
     */
    public function toHeaderValue(): string
    {
        return json_encode(ObjectSerializer::sanitizeForSerialization($this));
    }
}


