diff --git a/.konfig/generate-id.txt b/.konfig/generate-id.txt index ac8970b..7d9155f 100644 --- a/.konfig/generate-id.txt +++ b/.konfig/generate-id.txt @@ -1 +1 @@ -611ac354-b83d-44d0-a142-42aef9ad9b18 \ No newline at end of file +5af0f055-58bb-4809-9d3f-bebabdbb2695 \ No newline at end of file diff --git a/lib/Model/AccountUniversalActivity.php b/lib/Model/AccountUniversalActivity.php index 021295d..57cdf58 100644 --- a/lib/Model/AccountUniversalActivity.php +++ b/lib/Model/AccountUniversalActivity.php @@ -53,6 +53,7 @@ class AccountUniversalActivity implements ModelInterface, ArrayAccess, \JsonSeri protected static $openAPITypes = [ 'id' => 'string', 'symbol' => '\SnapTrade\Model\AccountUniversalActivitySymbol', + 'currency_universal_symbol' => '\SnapTrade\Model\AccountUniversalActivityCurrencyUniversalSymbol', 'option_symbol' => '\SnapTrade\Model\AccountUniversalActivityOptionSymbol', 'price' => 'float', 'units' => 'float', @@ -79,6 +80,7 @@ class AccountUniversalActivity implements ModelInterface, ArrayAccess, \JsonSeri protected static $openAPIFormats = [ 'id' => null, 'symbol' => null, + 'currency_universal_symbol' => null, 'option_symbol' => null, 'price' => null, 'units' => null, @@ -103,11 +105,12 @@ class AccountUniversalActivity implements ModelInterface, ArrayAccess, \JsonSeri protected static array $openAPINullables = [ 'id' => false, 'symbol' => true, + 'currency_universal_symbol' => true, 'option_symbol' => true, 'price' => false, 'units' => false, 'amount' => true, - 'currency' => false, + 'currency' => true, 'type' => false, 'option_type' => false, 'description' => false, @@ -207,6 +210,7 @@ public function isNullableSetToNull(string $property): bool protected static $attributeMap = [ 'id' => 'id', 'symbol' => 'symbol', + 'currency_universal_symbol' => 'currency_universal_symbol', 'option_symbol' => 'option_symbol', 'price' => 'price', 'units' => 'units', @@ -231,6 +235,7 @@ public function isNullableSetToNull(string $property): bool protected static $setters = [ 'id' => 'setId', 'symbol' => 'setSymbol', + 'currency_universal_symbol' => 'setCurrencyUniversalSymbol', 'option_symbol' => 'setOptionSymbol', 'price' => 'setPrice', 'units' => 'setUnits', @@ -255,6 +260,7 @@ public function isNullableSetToNull(string $property): bool protected static $getters = [ 'id' => 'getId', 'symbol' => 'getSymbol', + 'currency_universal_symbol' => 'getCurrencyUniversalSymbol', 'option_symbol' => 'getOptionSymbol', 'price' => 'getPrice', 'units' => 'getUnits', @@ -330,6 +336,7 @@ public function __construct(array $data = null) { $this->setIfExists('id', $data ?? [], null); $this->setIfExists('symbol', $data ?? [], null); + $this->setIfExists('currency_universal_symbol', $data ?? [], null); $this->setIfExists('option_symbol', $data ?? [], null); $this->setIfExists('price', $data ?? [], null); $this->setIfExists('units', $data ?? [], null); @@ -453,6 +460,42 @@ public function setSymbol($symbol) return $this; } + /** + * Gets currency_universal_symbol + * + * @return \SnapTrade\Model\AccountUniversalActivityCurrencyUniversalSymbol|null + */ + public function getCurrencyUniversalSymbol() + { + return $this->container['currency_universal_symbol']; + } + + /** + * Sets currency_universal_symbol + * + * @param \SnapTrade\Model\AccountUniversalActivityCurrencyUniversalSymbol|null $currency_universal_symbol currency_universal_symbol + * + * @return self + */ + public function setCurrencyUniversalSymbol($currency_universal_symbol) + { + + if (is_null($currency_universal_symbol)) { + array_push($this->openAPINullablesSetToNull, 'currency_universal_symbol'); + } else { + $nullablesSetToNull = $this->getOpenAPINullablesSetToNull(); + $index = array_search('currency_universal_symbol', $nullablesSetToNull); + if ($index !== FALSE) { + unset($nullablesSetToNull[$index]); + $this->setOpenAPINullablesSetToNull($nullablesSetToNull); + } + } + + $this->container['currency_universal_symbol'] = $currency_universal_symbol; + + return $this; + } + /** * Gets option_symbol * @@ -604,7 +647,14 @@ public function setCurrency($currency) { if (is_null($currency)) { - throw new \InvalidArgumentException('non-nullable currency cannot be null'); + array_push($this->openAPINullablesSetToNull, 'currency'); + } else { + $nullablesSetToNull = $this->getOpenAPINullablesSetToNull(); + $index = array_search('currency', $nullablesSetToNull); + if ($index !== FALSE) { + unset($nullablesSetToNull[$index]); + $this->setOpenAPINullablesSetToNull($nullablesSetToNull); + } } $this->container['currency'] = $currency; diff --git a/lib/Model/AccountUniversalActivityCurrency.php b/lib/Model/AccountUniversalActivityCurrency.php index 87d9ebc..984dd07 100644 --- a/lib/Model/AccountUniversalActivityCurrency.php +++ b/lib/Model/AccountUniversalActivityCurrency.php @@ -30,7 +30,7 @@ * AccountUniversalActivityCurrency Class Doc Comment * * @category Class - * @description The currency in which the transaction `price` and `amount` is denominated. + * @description The currency in which the transaction `price`, `amount`, and `fee` are denominated. This is `null` when those values are denominated in `currency_universal_symbol`. * @package SnapTrade * @implements \ArrayAccess */ diff --git a/lib/Model/AccountUniversalActivityCurrencyUniversalSymbol.php b/lib/Model/AccountUniversalActivityCurrencyUniversalSymbol.php new file mode 100644 index 0000000..ae71f2c --- /dev/null +++ b/lib/Model/AccountUniversalActivityCurrencyUniversalSymbol.php @@ -0,0 +1,714 @@ + + */ +class AccountUniversalActivityCurrencyUniversalSymbol implements ModelInterface, ArrayAccess, \JsonSerializable +{ + public const DISCRIMINATOR = null; + + /** + * The original name of the model. + * + * @var string + */ + protected static $openAPIModelName = 'AccountUniversalActivity_currency_universal_symbol'; + + /** + * Array of property to type mappings. Used for (de)serialization + * + * @var string[] + */ + protected static $openAPITypes = [ + 'id' => 'string', + 'symbol' => 'string', + 'raw_symbol' => 'string', + 'description' => 'string', + 'currency' => '\SnapTrade\Model\SymbolCurrency', + 'exchange' => '\SnapTrade\Model\SymbolExchange', + 'type' => '\SnapTrade\Model\SecurityType', + 'figi_code' => 'string', + 'figi_instrument' => '\SnapTrade\Model\StockInstrumentFigiInstrument' + ]; + + /** + * Array of property to format mappings. Used for (de)serialization + * + * @var string[] + * @phpstan-var array + * @psalm-var array + */ + protected static $openAPIFormats = [ + 'id' => 'uuid', + 'symbol' => null, + 'raw_symbol' => null, + 'description' => null, + 'currency' => null, + 'exchange' => null, + 'type' => null, + 'figi_code' => null, + 'figi_instrument' => null + ]; + + /** + * Array of nullable properties. Used for (de)serialization + * + * @var boolean[] + */ + protected static array $openAPINullables = [ + 'id' => false, + 'symbol' => false, + 'raw_symbol' => false, + 'description' => true, + 'currency' => false, + 'exchange' => false, + 'type' => false, + 'figi_code' => true, + 'figi_instrument' => true + ]; + + /** + * If a nullable field gets set to null, insert it here + * + * @var boolean[] + */ + protected array $openAPINullablesSetToNull = []; + + /** + * Array of property to type mappings. Used for (de)serialization + * + * @return array + */ + public static function openAPITypes() + { + return self::$openAPITypes; + } + + /** + * Array of property to format mappings. Used for (de)serialization + * + * @return array + */ + public static function openAPIFormats() + { + return self::$openAPIFormats; + } + + /** + * Array of nullable properties + * + * @return array + */ + protected static function openAPINullables(): array + { + return self::$openAPINullables; + } + + /** + * Array of nullable field names deliberately set to null + * + * @return boolean[] + */ + private function getOpenAPINullablesSetToNull(): array + { + return $this->openAPINullablesSetToNull; + } + + /** + * Setter - Array of nullable field names deliberately set to null + * + * @param boolean[] $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 string[] + */ + protected static $attributeMap = [ + 'id' => 'id', + 'symbol' => 'symbol', + 'raw_symbol' => 'raw_symbol', + 'description' => 'description', + 'currency' => 'currency', + 'exchange' => 'exchange', + 'type' => 'type', + 'figi_code' => 'figi_code', + 'figi_instrument' => 'figi_instrument' + ]; + + /** + * Array of attributes to setter functions (for deserialization of responses) + * + * @var string[] + */ + protected static $setters = [ + 'id' => 'setId', + 'symbol' => 'setSymbol', + 'raw_symbol' => 'setRawSymbol', + 'description' => 'setDescription', + 'currency' => 'setCurrency', + 'exchange' => 'setExchange', + 'type' => 'setType', + 'figi_code' => 'setFigiCode', + 'figi_instrument' => 'setFigiInstrument' + ]; + + /** + * Array of attributes to getter functions (for serialization of requests) + * + * @var string[] + */ + protected static $getters = [ + 'id' => 'getId', + 'symbol' => 'getSymbol', + 'raw_symbol' => 'getRawSymbol', + 'description' => 'getDescription', + 'currency' => 'getCurrency', + 'exchange' => 'getExchange', + 'type' => 'getType', + 'figi_code' => 'getFigiCode', + 'figi_instrument' => 'getFigiInstrument' + ]; + + /** + * Array of attributes where the key is the local name, + * and the value is the original name + * + * @return array + */ + public static function attributeMap() + { + return self::$attributeMap; + } + + /** + * Array of attributes to setter functions (for deserialization of responses) + * + * @return array + */ + public static function setters() + { + return self::$setters; + } + + /** + * Array of attributes to getter functions (for serialization of requests) + * + * @return array + */ + public static function getters() + { + return self::$getters; + } + + /** + * The original name of the model. + * + * @return string + */ + public function getModelName() + { + return self::$openAPIModelName; + } + + + /** + * Associative array for storing property values + * + * @var mixed[] + */ + protected $container = []; + + /** + * Constructor + * + * @param mixed[] $data Associated array of property values + * initializing the model + */ + public function __construct(array $data = null) + { + $this->setIfExists('id', $data ?? [], null); + $this->setIfExists('symbol', $data ?? [], null); + $this->setIfExists('raw_symbol', $data ?? [], null); + $this->setIfExists('description', $data ?? [], null); + $this->setIfExists('currency', $data ?? [], null); + $this->setIfExists('exchange', $data ?? [], null); + $this->setIfExists('type', $data ?? [], null); + $this->setIfExists('figi_code', $data ?? [], null); + $this->setIfExists('figi_instrument', $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, $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 array invalid properties with reasons + */ + public function listInvalidProperties() + { + $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() + { + return count($this->listInvalidProperties()) === 0; + } + + + /** + * Gets id + * + * @return string|null + */ + public function getId() + { + return $this->container['id']; + } + + /** + * Sets id + * + * @param string|null $id Unique identifier for the symbol within SnapTrade. This is the ID used to reference the symbol in SnapTrade API calls. + * + * @return self + */ + public function setId($id) + { + + if (is_null($id)) { + throw new \InvalidArgumentException('non-nullable id cannot be null'); + } + + $this->container['id'] = $id; + + return $this; + } + + /** + * Gets symbol + * + * @return string|null + */ + public function getSymbol() + { + return $this->container['symbol']; + } + + /** + * Sets symbol + * + * @param string|null $symbol The security's trading ticker symbol. For example \"AAPL\" for Apple Inc. We largely follow the [Yahoo Finance ticker format](https://help.yahoo.com/kb/SLN2310.html)(click on \"Yahoo Finance Market Coverage and Data Delays\"). For example, for securities traded on the Toronto Stock Exchange, the symbol has a '.TO' suffix. For securities traded on NASDAQ or NYSE, the symbol does not have a suffix. + * + * @return self + */ + public function setSymbol($symbol) + { + + if (is_null($symbol)) { + throw new \InvalidArgumentException('non-nullable symbol cannot be null'); + } + + $this->container['symbol'] = $symbol; + + return $this; + } + + /** + * Gets raw_symbol + * + * @return string|null + */ + public function getRawSymbol() + { + return $this->container['raw_symbol']; + } + + /** + * Sets raw_symbol + * + * @param string|null $raw_symbol The raw symbol is `symbol` with the exchange suffix removed. For example, if `symbol` is \"VAB.TO\", then `raw_symbol` is \"VAB\". + * + * @return self + */ + public function setRawSymbol($raw_symbol) + { + + if (is_null($raw_symbol)) { + throw new \InvalidArgumentException('non-nullable raw_symbol cannot be null'); + } + + $this->container['raw_symbol'] = $raw_symbol; + + return $this; + } + + /** + * Gets description + * + * @return string|null + */ + public function getDescription() + { + return $this->container['description']; + } + + /** + * Sets description + * + * @param string|null $description A human-readable description of the security. This is usually the company name or ETF name. + * + * @return self + */ + public function setDescription($description) + { + + if (is_null($description)) { + array_push($this->openAPINullablesSetToNull, 'description'); + } else { + $nullablesSetToNull = $this->getOpenAPINullablesSetToNull(); + $index = array_search('description', $nullablesSetToNull); + if ($index !== FALSE) { + unset($nullablesSetToNull[$index]); + $this->setOpenAPINullablesSetToNull($nullablesSetToNull); + } + } + + $this->container['description'] = $description; + + return $this; + } + + /** + * Gets currency + * + * @return \SnapTrade\Model\SymbolCurrency|null + */ + public function getCurrency() + { + return $this->container['currency']; + } + + /** + * Sets currency + * + * @param \SnapTrade\Model\SymbolCurrency|null $currency currency + * + * @return self + */ + public function setCurrency($currency) + { + + if (is_null($currency)) { + throw new \InvalidArgumentException('non-nullable currency cannot be null'); + } + + $this->container['currency'] = $currency; + + return $this; + } + + /** + * Gets exchange + * + * @return \SnapTrade\Model\SymbolExchange|null + */ + public function getExchange() + { + return $this->container['exchange']; + } + + /** + * Sets exchange + * + * @param \SnapTrade\Model\SymbolExchange|null $exchange exchange + * + * @return self + */ + public function setExchange($exchange) + { + + if (is_null($exchange)) { + throw new \InvalidArgumentException('non-nullable exchange cannot be null'); + } + + $this->container['exchange'] = $exchange; + + return $this; + } + + /** + * Gets type + * + * @return \SnapTrade\Model\SecurityType|null + */ + public function getType() + { + return $this->container['type']; + } + + /** + * Sets type + * + * @param \SnapTrade\Model\SecurityType|null $type type + * + * @return self + */ + public function setType($type) + { + + if (is_null($type)) { + throw new \InvalidArgumentException('non-nullable type cannot be null'); + } + + $this->container['type'] = $type; + + return $this; + } + + /** + * Gets figi_code + * + * @return string|null + */ + public function getFigiCode() + { + return $this->container['figi_code']; + } + + /** + * Sets figi_code + * + * @param string|null $figi_code This identifier is unique per security per trading venue. See section 1.4.1 of the [FIGI Standard](https://www.openfigi.com/assets/local/figi-allocation-rules.pdf) for more information. This value should be the same as the `figi_code` in the `figi_instrument` child property. + * + * @return self + */ + public function setFigiCode($figi_code) + { + + if (is_null($figi_code)) { + array_push($this->openAPINullablesSetToNull, 'figi_code'); + } else { + $nullablesSetToNull = $this->getOpenAPINullablesSetToNull(); + $index = array_search('figi_code', $nullablesSetToNull); + if ($index !== FALSE) { + unset($nullablesSetToNull[$index]); + $this->setOpenAPINullablesSetToNull($nullablesSetToNull); + } + } + + $this->container['figi_code'] = $figi_code; + + return $this; + } + + /** + * Gets figi_instrument + * + * @return \SnapTrade\Model\StockInstrumentFigiInstrument|null + */ + public function getFigiInstrument() + { + return $this->container['figi_instrument']; + } + + /** + * Sets figi_instrument + * + * @param \SnapTrade\Model\StockInstrumentFigiInstrument|null $figi_instrument figi_instrument + * + * @return self + */ + public function setFigiInstrument($figi_instrument) + { + + if (is_null($figi_instrument)) { + array_push($this->openAPINullablesSetToNull, 'figi_instrument'); + } else { + $nullablesSetToNull = $this->getOpenAPINullablesSetToNull(); + $index = array_search('figi_instrument', $nullablesSetToNull); + if ($index !== FALSE) { + unset($nullablesSetToNull[$index]); + $this->setOpenAPINullablesSetToNull($nullablesSetToNull); + } + } + + $this->container['figi_instrument'] = $figi_instrument; + + return $this; + } + /** + * Returns true if offset exists. False otherwise. + * + * @param integer $offset Offset + * + * @return boolean + */ + public function offsetExists($offset): bool + { + return isset($this->container[$offset]); + } + + /** + * Gets offset. + * + * @param integer $offset Offset + * + * @return mixed|null + */ + #[\ReturnTypeWillChange] + public function offsetGet($offset) + { + 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($offset, $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($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() + { + return ObjectSerializer::sanitizeForSerialization($this); + } + + /** + * Gets the string presentation of the object + * + * @return string + */ + public function __toString() + { + return json_encode( + ObjectSerializer::sanitizeForSerialization($this), + JSON_PRETTY_PRINT + ); + } + + /** + * Gets a header-safe presentation of the object + * + * @return string + */ + public function toHeaderValue() + { + return json_encode(ObjectSerializer::sanitizeForSerialization($this)); + } +} + + diff --git a/lib/Model/UniversalActivity.php b/lib/Model/UniversalActivity.php index bc5f241..b1dfa6e 100644 --- a/lib/Model/UniversalActivity.php +++ b/lib/Model/UniversalActivity.php @@ -54,6 +54,7 @@ class UniversalActivity implements ModelInterface, ArrayAccess, \JsonSerializabl 'id' => 'string', 'account' => '\SnapTrade\Model\AccountSimple', 'symbol' => '\SnapTrade\Model\AccountUniversalActivitySymbol', + 'currency_universal_symbol' => '\SnapTrade\Model\AccountUniversalActivityCurrencyUniversalSymbol', 'option_symbol' => '\SnapTrade\Model\AccountUniversalActivityOptionSymbol', 'price' => 'float', 'units' => 'float', @@ -81,6 +82,7 @@ class UniversalActivity implements ModelInterface, ArrayAccess, \JsonSerializabl 'id' => null, 'account' => null, 'symbol' => null, + 'currency_universal_symbol' => null, 'option_symbol' => null, 'price' => null, 'units' => null, @@ -106,11 +108,12 @@ class UniversalActivity implements ModelInterface, ArrayAccess, \JsonSerializabl 'id' => false, 'account' => false, 'symbol' => true, + 'currency_universal_symbol' => true, 'option_symbol' => true, 'price' => false, 'units' => false, 'amount' => true, - 'currency' => false, + 'currency' => true, 'type' => false, 'option_type' => false, 'description' => false, @@ -211,6 +214,7 @@ public function isNullableSetToNull(string $property): bool 'id' => 'id', 'account' => 'account', 'symbol' => 'symbol', + 'currency_universal_symbol' => 'currency_universal_symbol', 'option_symbol' => 'option_symbol', 'price' => 'price', 'units' => 'units', @@ -236,6 +240,7 @@ public function isNullableSetToNull(string $property): bool 'id' => 'setId', 'account' => 'setAccount', 'symbol' => 'setSymbol', + 'currency_universal_symbol' => 'setCurrencyUniversalSymbol', 'option_symbol' => 'setOptionSymbol', 'price' => 'setPrice', 'units' => 'setUnits', @@ -261,6 +266,7 @@ public function isNullableSetToNull(string $property): bool 'id' => 'getId', 'account' => 'getAccount', 'symbol' => 'getSymbol', + 'currency_universal_symbol' => 'getCurrencyUniversalSymbol', 'option_symbol' => 'getOptionSymbol', 'price' => 'getPrice', 'units' => 'getUnits', @@ -337,6 +343,7 @@ public function __construct(array $data = null) $this->setIfExists('id', $data ?? [], null); $this->setIfExists('account', $data ?? [], null); $this->setIfExists('symbol', $data ?? [], null); + $this->setIfExists('currency_universal_symbol', $data ?? [], null); $this->setIfExists('option_symbol', $data ?? [], null); $this->setIfExists('price', $data ?? [], null); $this->setIfExists('units', $data ?? [], null); @@ -489,6 +496,42 @@ public function setSymbol($symbol) return $this; } + /** + * Gets currency_universal_symbol + * + * @return \SnapTrade\Model\AccountUniversalActivityCurrencyUniversalSymbol|null + */ + public function getCurrencyUniversalSymbol() + { + return $this->container['currency_universal_symbol']; + } + + /** + * Sets currency_universal_symbol + * + * @param \SnapTrade\Model\AccountUniversalActivityCurrencyUniversalSymbol|null $currency_universal_symbol currency_universal_symbol + * + * @return self + */ + public function setCurrencyUniversalSymbol($currency_universal_symbol) + { + + if (is_null($currency_universal_symbol)) { + array_push($this->openAPINullablesSetToNull, 'currency_universal_symbol'); + } else { + $nullablesSetToNull = $this->getOpenAPINullablesSetToNull(); + $index = array_search('currency_universal_symbol', $nullablesSetToNull); + if ($index !== FALSE) { + unset($nullablesSetToNull[$index]); + $this->setOpenAPINullablesSetToNull($nullablesSetToNull); + } + } + + $this->container['currency_universal_symbol'] = $currency_universal_symbol; + + return $this; + } + /** * Gets option_symbol * @@ -640,7 +683,14 @@ public function setCurrency($currency) { if (is_null($currency)) { - throw new \InvalidArgumentException('non-nullable currency cannot be null'); + array_push($this->openAPINullablesSetToNull, 'currency'); + } else { + $nullablesSetToNull = $this->getOpenAPINullablesSetToNull(); + $index = array_search('currency', $nullablesSetToNull); + if ($index !== FALSE) { + unset($nullablesSetToNull[$index]); + $this->setOpenAPINullablesSetToNull($nullablesSetToNull); + } } $this->container['currency'] = $currency; diff --git a/test/Model/AccountUniversalActivityCurrencyTest.php b/test/Model/AccountUniversalActivityCurrencyTest.php index b0ebe52..9888d7d 100644 --- a/test/Model/AccountUniversalActivityCurrencyTest.php +++ b/test/Model/AccountUniversalActivityCurrencyTest.php @@ -29,7 +29,7 @@ * AccountUniversalActivityCurrencyTest Class Doc Comment * * @category Class - * @description The currency in which the transaction `price` and `amount` is denominated. + * @description The currency in which the transaction `price`, `amount`, and `fee` are denominated. This is `null` when those values are denominated in `currency_universal_symbol`. * @package SnapTrade */ class AccountUniversalActivityCurrencyTest extends TestCase diff --git a/test/Model/AccountUniversalActivityCurrencyUniversalSymbolTest.php b/test/Model/AccountUniversalActivityCurrencyUniversalSymbolTest.php new file mode 100644 index 0000000..35c57db --- /dev/null +++ b/test/Model/AccountUniversalActivityCurrencyUniversalSymbolTest.php @@ -0,0 +1,155 @@ +markTestIncomplete('Not implemented'); + } + + /** + * Test attribute "id" + */ + public function testPropertyId() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + + /** + * Test attribute "symbol" + */ + public function testPropertySymbol() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + + /** + * Test attribute "raw_symbol" + */ + public function testPropertyRawSymbol() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + + /** + * Test attribute "description" + */ + public function testPropertyDescription() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + + /** + * Test attribute "currency" + */ + public function testPropertyCurrency() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + + /** + * Test attribute "exchange" + */ + public function testPropertyExchange() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + + /** + * Test attribute "type" + */ + public function testPropertyType() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + + /** + * Test attribute "figi_code" + */ + public function testPropertyFigiCode() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + + /** + * Test attribute "figi_instrument" + */ + public function testPropertyFigiInstrument() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } +} diff --git a/test/Model/AccountUniversalActivityTest.php b/test/Model/AccountUniversalActivityTest.php index d904a35..7013ecb 100644 --- a/test/Model/AccountUniversalActivityTest.php +++ b/test/Model/AccountUniversalActivityTest.php @@ -90,6 +90,15 @@ public function testPropertySymbol() $this->markTestIncomplete('Not implemented'); } + /** + * Test attribute "currency_universal_symbol" + */ + public function testPropertyCurrencyUniversalSymbol() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + /** * Test attribute "option_symbol" */ diff --git a/test/Model/UniversalActivityTest.php b/test/Model/UniversalActivityTest.php index 7c835a8..55c7e9f 100644 --- a/test/Model/UniversalActivityTest.php +++ b/test/Model/UniversalActivityTest.php @@ -99,6 +99,15 @@ public function testPropertySymbol() $this->markTestIncomplete('Not implemented'); } + /** + * Test attribute "currency_universal_symbol" + */ + public function testPropertyCurrencyUniversalSymbol() + { + // TODO: implement + $this->markTestIncomplete('Not implemented'); + } + /** * Test attribute "option_symbol" */