lusid-sdk 2.1.991__py3-none-any.whl → 2.2.1__py3-none-any.whl

lusid/models/reconciliation_configuration.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.reconciliation_side_configuration import ReconciliationSideConfiguration
 from lusid.models.resource_id import ResourceId
 
@@ -29,7 +31,7 @@ class ReconciliationConfiguration(BaseModel):
     """
     left: Optional[ReconciliationSideConfiguration] = None
     right: Optional[ReconciliationSideConfiguration] = None
-    mapping_id: Optional[ResourceId] = Field(None, alias="mappingId")
+    mapping_id: Optional[ResourceId] = Field(default=None, alias="mappingId")
     __properties = ["left", "right", "mappingId"]
 
     class Config:
@@ -90,3 +92,5 @@ class ReconciliationConfiguration(BaseModel):
             "mapping_id": ResourceId.from_dict(obj.get("mappingId")) if obj.get("mappingId") is not None else None
         })
         return _obj
+
+ReconciliationConfiguration.update_forward_refs()

lusid/models/reconciliation_id.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, StrictStr 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.data_scope import DataScope
 
 class ReconciliationId(BaseModel):
@@ -86,3 +88,5 @@ class ReconciliationId(BaseModel):
             "identifier": obj.get("identifier")
         })
         return _obj
+
+ReconciliationId.update_forward_refs()

lusid/models/reconciliation_left_right_address_key_pair.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 class ReconciliationLeftRightAddressKeyPair(BaseModel):
     """
@@ -77,3 +79,5 @@ class ReconciliationLeftRightAddressKeyPair(BaseModel):
             "right": obj.get("right")
         })
         return _obj
+
+ReconciliationLeftRightAddressKeyPair.update_forward_refs()

lusid/models/reconciliation_line.py

@@ -18,17 +18,19 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 class ReconciliationLine(BaseModel):
     """
     In evaluating a left and right hand side holding or valuation set, two data records result. These are then compared based on a set of  rules. This results in either a match or failure to match. If there is a match both left and right will be present, otherwise one will not.  A difference will be present if a match was calculated.  The options used in comparison may result in elision of results where an exact or tolerable match is made.  # noqa: E501
     """
-    left: Optional[Dict[str, Any]] = Field(None, description="Left hand side of the comparison")
-    right: Optional[Dict[str, Any]] = Field(None, description="Right hand side of the comparison")
-    difference: Optional[Dict[str, Any]] = Field(None, description="Difference between LHS and RHS of comparison")
-    result_comparison: Optional[Dict[str, Any]] = Field(None, alias="resultComparison", description="The logical or semantic description of the difference, e.g. \"Matches\" or \"MatchesWithTolerance\" or \"Failed\".")
+    left: Optional[Dict[str, Any]] = Field(default=None, description="Left hand side of the comparison")
+    right: Optional[Dict[str, Any]] = Field(default=None, description="Right hand side of the comparison")
+    difference: Optional[Dict[str, Any]] = Field(default=None, description="Difference between LHS and RHS of comparison")
+    result_comparison: Optional[Dict[str, Any]] = Field(default=None, description="The logical or semantic description of the difference, e.g. \"Matches\" or \"MatchesWithTolerance\" or \"Failed\".", alias="resultComparison")
     __properties = ["left", "right", "difference", "resultComparison"]
 
     class Config:
@@ -101,3 +103,5 @@ class ReconciliationLine(BaseModel):
             "result_comparison": obj.get("resultComparison")
         })
         return _obj
+
+ReconciliationLine.update_forward_refs()

lusid/models/reconciliation_request.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.reconciliation_left_right_address_key_pair import ReconciliationLeftRightAddressKeyPair
 from lusid.models.reconciliation_rule import ReconciliationRule
 from lusid.models.valuation_request import ValuationRequest
@@ -28,11 +30,11 @@ class ReconciliationRequest(BaseModel):
     """
     Specification for the reconciliation request. Left and Right hand sides are constructed. Each consists of a valuation of a portfolio  using an aggregation request. The results of this can then be compared to each other. The difference, which is effectively a risk based  difference allows comparison of the effects of changing a recipe, valuation date, or (though it may or may not make logical sense) a portfolio.  For instance, one might look at the difference in risk caused by the addition of transaction to a portfolio, or through changing the valuation  methodology or system.  # noqa: E501
     """
-    left: ValuationRequest = Field(...)
-    right: ValuationRequest = Field(...)
-    left_to_right_mapping: Optional[conlist(ReconciliationLeftRightAddressKeyPair)] = Field(None, alias="leftToRightMapping", description="The mapping from property keys requested by left aggregation to property keys on right hand side")
-    comparison_rules: Optional[conlist(ReconciliationRule)] = Field(None, alias="comparisonRules", description="The set of rules to be used in comparing values. These are the rules that determine what constitutes a match.  The simplest is obviously an exact one-for-one comparison, but tolerances on numerical or date time values and  case-insensitive string comparison are supported amongst other types.")
-    preserve_keys: Optional[conlist(StrictStr)] = Field(None, alias="preserveKeys", description="List of keys to preserve (from rhs) in the diff. Used in conjunction with filtering/grouping.  If two values are equal, for a given key then the value is elided from the results. Setting it here  will preserve it (takes the values from the RHS and puts it into the line by line results).")
+    left: ValuationRequest
+    right: ValuationRequest
+    left_to_right_mapping: Optional[List[ReconciliationLeftRightAddressKeyPair]] = Field(default=None, description="The mapping from property keys requested by left aggregation to property keys on right hand side", alias="leftToRightMapping")
+    comparison_rules: Optional[List[ReconciliationRule]] = Field(default=None, description="The set of rules to be used in comparing values. These are the rules that determine what constitutes a match.  The simplest is obviously an exact one-for-one comparison, but tolerances on numerical or date time values and  case-insensitive string comparison are supported amongst other types.", alias="comparisonRules")
+    preserve_keys: Optional[List[StrictStr]] = Field(default=None, description="List of keys to preserve (from rhs) in the diff. Used in conjunction with filtering/grouping.  If two values are equal, for a given key then the value is elided from the results. Setting it here  will preserve it (takes the values from the RHS and puts it into the line by line results).", alias="preserveKeys")
     __properties = ["left", "right", "leftToRightMapping", "comparisonRules", "preserveKeys"]
 
     class Config:
@@ -121,3 +123,5 @@ class ReconciliationRequest(BaseModel):
             "preserve_keys": obj.get("preserveKeys")
         })
         return _obj
+
+ReconciliationRequest.update_forward_refs()

lusid/models/reconciliation_response.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.reconciliation_line import ReconciliationLine
 from lusid.models.result_data_schema import ResultDataSchema
 
@@ -27,8 +29,8 @@ class ReconciliationResponse(BaseModel):
     """
     Class representing the set of comparisons that result from comparing holdings and their valuations between two separate evaluations.  # noqa: E501
     """
-    comparisons: Optional[conlist(ReconciliationLine)] = Field(None, description="List of comparisons of left to right hand sides.")
-    data_schema: Optional[ResultDataSchema] = Field(None, alias="dataSchema")
+    comparisons: Optional[List[ReconciliationLine]] = Field(default=None, description="List of comparisons of left to right hand sides.")
+    data_schema: Optional[ResultDataSchema] = Field(default=None, alias="dataSchema")
     __properties = ["comparisons", "dataSchema"]
 
     class Config:
@@ -94,3 +96,5 @@ class ReconciliationResponse(BaseModel):
             "data_schema": ResultDataSchema.from_dict(obj.get("dataSchema")) if obj.get("dataSchema") is not None else None
         })
         return _obj
+
+ReconciliationResponse.update_forward_refs()

lusid/models/reconciliation_rule.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Union
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, validator 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 import lusid.models
 
 class ReconciliationRule(BaseModel):
@@ -79,14 +81,19 @@ class ReconciliationRule(BaseModel):
                                     'SchedulerJobResponse', 
                                     'SleepResponse',
                                     'Library',
-                                    'LibraryResponse']:
+                                    'LibraryResponse',
+                                    'DayRegularity',
+                                    'RelativeMonthRegularity',
+                                    'SpecificMonthRegularity',
+                                    'WeekRegularity',
+                                    'YearRegularity']:
            return value
         
         # Only validate the 'type' property of the class
         if "rule_type" != "type":
             return value
 
-        if value not in ('ReconcileNumericRule', 'ReconcileDateTimeRule', 'ReconcileStringRule', 'ReconcileExact'):
+        if value not in ['ReconcileNumericRule', 'ReconcileDateTimeRule', 'ReconcileStringRule', 'ReconcileExact']:
             raise ValueError("must be one of enum values ('ReconcileNumericRule', 'ReconcileDateTimeRule', 'ReconcileStringRule', 'ReconcileExact')")
         return value
 
@@ -155,3 +162,5 @@ class ReconciliationRule(BaseModel):
             raise ValueError("ReconciliationRule failed to lookup discriminator value from " +
                              json.dumps(obj) + ". Discriminator property name: " + cls.__discriminator_property_name +
                              ", mapping: " + json.dumps(cls.__discriminator_value_class_map))
+
+ReconciliationRule.update_forward_refs()

lusid/models/reconciliation_rule_type.py

@@ -17,8 +17,10 @@ import pprint
 import re  # noqa: F401
 from aenum import Enum, no_arg
 
-
-
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 
 class ReconciliationRuleType(str, Enum):

lusid/models/reconciliation_side_configuration.py

@@ -17,18 +17,20 @@ import pprint
 import re  # noqa: F401
 import json
 
+
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
 from datetime import datetime
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr 
 from lusid.models.resource_id import ResourceId
 
 class ReconciliationSideConfiguration(BaseModel):
     """
     Specification for one side of a valuations/positions scheduled reconciliation  # noqa: E501
     """
-    recipe_id: Optional[ResourceId] = Field(None, alias="recipeId")
-    effective_at: Optional[datetime] = Field(None, alias="effectiveAt")
-    as_at: Optional[datetime] = Field(None, alias="asAt")
+    recipe_id: Optional[ResourceId] = Field(default=None, alias="recipeId")
+    effective_at: Optional[datetime] = Field(default=None, alias="effectiveAt")
+    as_at: Optional[datetime] = Field(default=None, alias="asAt")
     currency:  Optional[StrictStr] = Field(None,alias="currency") 
     __properties = ["recipeId", "effectiveAt", "asAt", "currency"]
 
@@ -100,3 +102,5 @@ class ReconciliationSideConfiguration(BaseModel):
             "currency": obj.get("currency")
         })
         return _obj
+
+ReconciliationSideConfiguration.update_forward_refs()

lusid/models/reconciliation_transactions.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.date_range import DateRange
 from lusid.models.resource_id import ResourceId
 
@@ -27,8 +29,8 @@ class ReconciliationTransactions(BaseModel):
     """
     Specification for the transactions of a scheduled reconciliation  # noqa: E501
     """
-    transaction_window: Optional[DateRange] = Field(None, alias="transactionWindow")
-    mapping_id: Optional[ResourceId] = Field(None, alias="mappingId")
+    transaction_window: Optional[DateRange] = Field(default=None, alias="transactionWindow")
+    mapping_id: Optional[ResourceId] = Field(default=None, alias="mappingId")
     __properties = ["transactionWindow", "mappingId"]
 
     class Config:
@@ -85,3 +87,5 @@ class ReconciliationTransactions(BaseModel):
             "mapping_id": ResourceId.from_dict(obj.get("mappingId")) if obj.get("mappingId") is not None else None
         })
         return _obj
+
+ReconciliationTransactions.update_forward_refs()

lusid/models/reference_data.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, conlist 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.field_definition import FieldDefinition
 from lusid.models.field_value import FieldValue
 
@@ -27,8 +29,8 @@ class ReferenceData(BaseModel):
     """
     ReferenceData
     """
-    field_definitions: conlist(FieldDefinition) = Field(..., alias="fieldDefinitions")
-    values: conlist(FieldValue) = Field(...)
+    field_definitions: List[FieldDefinition] = Field(alias="fieldDefinitions")
+    values: List[FieldValue]
     __properties = ["fieldDefinitions", "values"]
 
     class Config:
@@ -93,3 +95,5 @@ class ReferenceData(BaseModel):
             "values": [FieldValue.from_dict(_item) for _item in obj.get("values")] if obj.get("values") is not None else None
         })
         return _obj
+
+ReferenceData.update_forward_refs()

lusid/models/reference_instrument.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, Field, StrictStr, constr, validator 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.lusid_instrument import LusidInstrument
 
 class ReferenceInstrument(LusidInstrument):
@@ -83,14 +85,19 @@ class ReferenceInstrument(LusidInstrument):
                                     'SchedulerJobResponse', 
                                     'SleepResponse',
                                     'Library',
-                                    'LibraryResponse']:
+                                    'LibraryResponse',
+                                    'DayRegularity',
+                                    'RelativeMonthRegularity',
+                                    'SpecificMonthRegularity',
+                                    'WeekRegularity',
+                                    'YearRegularity']:
            return value
         
         # Only validate the 'type' property of the class
         if "instrument_type" != "type":
             return value
 
-        if value not in ('QuotedSecurity', 'InterestRateSwap', 'FxForward', 'Future', 'ExoticInstrument', 'FxOption', 'CreditDefaultSwap', 'InterestRateSwaption', 'Bond', 'EquityOption', 'FixedLeg', 'FloatingLeg', 'BespokeCashFlowsLeg', 'Unknown', 'TermDeposit', 'ContractForDifference', 'EquitySwap', 'CashPerpetual', 'CapFloor', 'CashSettled', 'CdsIndex', 'Basket', 'FundingLeg', 'FxSwap', 'ForwardRateAgreement', 'SimpleInstrument', 'Repo', 'Equity', 'ExchangeTradedOption', 'ReferenceInstrument', 'ComplexBond', 'InflationLinkedBond', 'InflationSwap', 'SimpleCashFlowLoan', 'TotalReturnSwap', 'InflationLeg', 'FundShareClass', 'FlexibleLoan', 'UnsettledCash', 'Cash', 'MasteredInstrument', 'LoanFacility', 'FlexibleDeposit', 'FlexibleRepo'):
+        if value not in ['QuotedSecurity', 'InterestRateSwap', 'FxForward', 'Future', 'ExoticInstrument', 'FxOption', 'CreditDefaultSwap', 'InterestRateSwaption', 'Bond', 'EquityOption', 'FixedLeg', 'FloatingLeg', 'BespokeCashFlowsLeg', 'Unknown', 'TermDeposit', 'ContractForDifference', 'EquitySwap', 'CashPerpetual', 'CapFloor', 'CashSettled', 'CdsIndex', 'Basket', 'FundingLeg', 'FxSwap', 'ForwardRateAgreement', 'SimpleInstrument', 'Repo', 'Equity', 'ExchangeTradedOption', 'ReferenceInstrument', 'ComplexBond', 'InflationLinkedBond', 'InflationSwap', 'SimpleCashFlowLoan', 'TotalReturnSwap', 'InflationLeg', 'FundShareClass', 'FlexibleLoan', 'UnsettledCash', 'Cash', 'MasteredInstrument', 'LoanFacility', 'FlexibleDeposit', 'FlexibleRepo']:
             raise ValueError("must be one of enum values ('QuotedSecurity', 'InterestRateSwap', 'FxForward', 'Future', 'ExoticInstrument', 'FxOption', 'CreditDefaultSwap', 'InterestRateSwaption', 'Bond', 'EquityOption', 'FixedLeg', 'FloatingLeg', 'BespokeCashFlowsLeg', 'Unknown', 'TermDeposit', 'ContractForDifference', 'EquitySwap', 'CashPerpetual', 'CapFloor', 'CashSettled', 'CdsIndex', 'Basket', 'FundingLeg', 'FxSwap', 'ForwardRateAgreement', 'SimpleInstrument', 'Repo', 'Equity', 'ExchangeTradedOption', 'ReferenceInstrument', 'ComplexBond', 'InflationLinkedBond', 'InflationSwap', 'SimpleCashFlowLoan', 'TotalReturnSwap', 'InflationLeg', 'FundShareClass', 'FlexibleLoan', 'UnsettledCash', 'Cash', 'MasteredInstrument', 'LoanFacility', 'FlexibleDeposit', 'FlexibleRepo')")
         return value
 
@@ -155,3 +162,5 @@ class ReferenceInstrument(LusidInstrument):
                 _obj.additional_properties[_key] = obj.get(_key)
 
         return _obj
+
+ReferenceInstrument.update_forward_refs()

lusid/models/reference_list.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Union
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, validator 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 import lusid.models
 
 class ReferenceList(BaseModel):
@@ -79,14 +81,19 @@ class ReferenceList(BaseModel):
                                     'SchedulerJobResponse', 
                                     'SleepResponse',
                                     'Library',
-                                    'LibraryResponse']:
+                                    'LibraryResponse',
+                                    'DayRegularity',
+                                    'RelativeMonthRegularity',
+                                    'SpecificMonthRegularity',
+                                    'WeekRegularity',
+                                    'YearRegularity']:
            return value
         
         # Only validate the 'type' property of the class
         if "reference_list_type" != "type":
             return value
 
-        if value not in ('PortfolioGroupIdList', 'PortfolioIdList', 'AddressKeyList', 'StringList', 'InstrumentList', 'DecimalList', 'PropertyList', 'FundIdList'):
+        if value not in ['PortfolioGroupIdList', 'PortfolioIdList', 'AddressKeyList', 'StringList', 'InstrumentList', 'DecimalList', 'PropertyList', 'FundIdList']:
             raise ValueError("must be one of enum values ('PortfolioGroupIdList', 'PortfolioIdList', 'AddressKeyList', 'StringList', 'InstrumentList', 'DecimalList', 'PropertyList', 'FundIdList')")
         return value
 
@@ -160,3 +167,5 @@ class ReferenceList(BaseModel):
             raise ValueError("ReferenceList failed to lookup discriminator value from " +
                              json.dumps(obj) + ". Discriminator property name: " + cls.__discriminator_property_name +
                              ", mapping: " + json.dumps(cls.__discriminator_value_class_map))
+
+ReferenceList.update_forward_refs()

lusid/models/reference_list_request.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist, constr 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.reference_list import ReferenceList
 from lusid.models.resource_id import ResourceId
 
@@ -27,11 +29,11 @@ class ReferenceListRequest(BaseModel):
     """
     ReferenceListRequest
     """
-    id: ResourceId = Field(...)
+    id: ResourceId
     name:  StrictStr = Field(...,alias="name", description="The name of the reference list.") 
     description:  Optional[StrictStr] = Field(None,alias="description", description="The description of the reference list.") 
-    tags: Optional[conlist(StrictStr)] = Field(None, description="The tags associated with the reference list.")
-    reference_list: ReferenceList = Field(..., alias="referenceList")
+    tags: Optional[List[StrictStr]] = Field(default=None, description="The tags associated with the reference list.")
+    reference_list: ReferenceList = Field(alias="referenceList")
     __properties = ["id", "name", "description", "tags", "referenceList"]
 
     class Config:
@@ -101,3 +103,5 @@ class ReferenceListRequest(BaseModel):
             "reference_list": ReferenceList.from_dict(obj.get("referenceList")) if obj.get("referenceList") is not None else None
         })
         return _obj
+
+ReferenceListRequest.update_forward_refs()

lusid/models/reference_list_response.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist, constr 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.link import Link
 from lusid.models.reference_list import ReferenceList
 from lusid.models.resource_id import ResourceId
@@ -29,13 +31,13 @@ class ReferenceListResponse(BaseModel):
     """
     ReferenceListResponse
     """
-    id: ResourceId = Field(...)
+    id: ResourceId
     name:  StrictStr = Field(...,alias="name", description="The name of the reference list.") 
     description:  Optional[StrictStr] = Field(None,alias="description", description="The description of the reference list.") 
-    tags: Optional[conlist(StrictStr)] = Field(None, description="The tags associated with the reference list.")
-    reference_list: ReferenceList = Field(..., alias="referenceList")
-    version: Version = Field(...)
-    links: Optional[conlist(Link)] = None
+    tags: Optional[List[StrictStr]] = Field(default=None, description="The tags associated with the reference list.")
+    reference_list: ReferenceList = Field(alias="referenceList")
+    version: Version
+    links: Optional[List[Link]] = None
     __properties = ["id", "name", "description", "tags", "referenceList", "version", "links"]
 
     class Config:
@@ -122,3 +124,5 @@ class ReferenceListResponse(BaseModel):
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj
+
+ReferenceListResponse.update_forward_refs()

lusid/models/reference_list_type.py

@@ -17,8 +17,10 @@ import pprint
 import re  # noqa: F401
 from aenum import Enum, no_arg
 
-
-
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 
 class ReferenceListType(str, Enum):

lusid/models/reference_portfolio_constituent.py

@@ -18,20 +18,22 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional, Union
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictFloat, StrictInt, StrictStr, constr 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.perpetual_property import PerpetualProperty
 
 class ReferencePortfolioConstituent(BaseModel):
     """
     ReferencePortfolioConstituent
     """
-    instrument_identifiers: Optional[Dict[str, StrictStr]] = Field(None, alias="instrumentIdentifiers", description="Unique instrument identifiers")
+    instrument_identifiers: Optional[Dict[str, Optional[StrictStr]]] = Field(default=None, description="Unique instrument identifiers", alias="instrumentIdentifiers")
     instrument_uid:  StrictStr = Field(...,alias="instrumentUid", description="LUSID's internal unique instrument identifier, resolved from the instrument identifiers") 
     currency:  StrictStr = Field(...,alias="currency", description="") 
-    properties: Optional[Dict[str, PerpetualProperty]] = Field(None, description="Properties associated with the constituent")
-    weight: Union[StrictFloat, StrictInt] = Field(...)
-    floating_weight: Optional[Union[StrictFloat, StrictInt]] = Field(None, alias="floatingWeight")
+    properties: Optional[Dict[str, PerpetualProperty]] = Field(default=None, description="Properties associated with the constituent")
+    weight: Union[StrictFloat, StrictInt]
+    floating_weight: Optional[Union[StrictFloat, StrictInt]] = Field(default=None, alias="floatingWeight")
     instrument_scope:  Optional[StrictStr] = Field(None,alias="instrumentScope", description="") 
     __properties = ["instrumentIdentifiers", "instrumentUid", "currency", "properties", "weight", "floatingWeight", "instrumentScope"]
 
@@ -120,3 +122,5 @@ class ReferencePortfolioConstituent(BaseModel):
             "instrument_scope": obj.get("instrumentScope")
         })
         return _obj
+
+ReferencePortfolioConstituent.update_forward_refs()

lusid/models/reference_portfolio_constituent_request.py

@@ -18,17 +18,19 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional, Union
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictFloat, StrictInt, StrictStr 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.perpetual_property import PerpetualProperty
 
 class ReferencePortfolioConstituentRequest(BaseModel):
     """
     ReferencePortfolioConstituentRequest
     """
-    instrument_identifiers: Dict[str, StrictStr] = Field(..., alias="instrumentIdentifiers", description="Unique instrument identifiers")
+    instrument_identifiers: Dict[str, Optional[StrictStr]] = Field(description="Unique instrument identifiers", alias="instrumentIdentifiers")
     properties: Optional[Dict[str, PerpetualProperty]] = None
-    weight: Union[StrictFloat, StrictInt] = Field(...)
+    weight: Union[StrictFloat, StrictInt]
     currency:  Optional[StrictStr] = Field(None,alias="currency", description="") 
     __properties = ["instrumentIdentifiers", "properties", "weight", "currency"]
 
@@ -104,3 +106,5 @@ class ReferencePortfolioConstituentRequest(BaseModel):
             "currency": obj.get("currency")
         })
         return _obj
+
+ReferencePortfolioConstituentRequest.update_forward_refs()

lusid/models/reference_portfolio_weight_type.py

@@ -17,8 +17,10 @@ import pprint
 import re  # noqa: F401
 from aenum import Enum, no_arg
 
-
-
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 
 
 class ReferencePortfolioWeightType(str, Enum):

lusid/models/related_entity.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictStr, conlist, constr 
+from typing import List, Dict, Optional, Any, Union, TYPE_CHECKING
+from typing_extensions import Annotated
+from pydantic.v1 import BaseModel, StrictStr, StrictInt, StrictBool, StrictFloat, StrictBytes, Field, validator, ValidationError, conlist, constr
+from datetime import datetime
 from lusid.models.entity_identifier import EntityIdentifier
 from lusid.models.lusid_unique_id import LusidUniqueId
 from lusid.models.model_property import ModelProperty
@@ -29,12 +31,12 @@ class RelatedEntity(BaseModel):
     Information about the other related entity in the relationship  # noqa: E501
     """
     entity_type:  StrictStr = Field(...,alias="entityType", description="The type of the entity.") 
-    entity_id: Dict[str, StrictStr] = Field(..., alias="entityId", description="The identifier of the other related entity in the relationship. It contains 'scope' and 'code' as keys for identifiers of a Portfolio or Portfolio Group, or 'idTypeScope', 'idTypeCode', 'code' as keys for identifiers of a Person or Legal entity, or 'scope', 'identifierType', 'identifierValue' as keys for identifiers of an Instrument")
+    entity_id: Dict[str, Optional[StrictStr]] = Field(description="The identifier of the other related entity in the relationship. It contains 'scope' and 'code' as keys for identifiers of a Portfolio or Portfolio Group, or 'idTypeScope', 'idTypeCode', 'code' as keys for identifiers of a Person or Legal entity, or 'scope', 'identifierType', 'identifierValue' as keys for identifiers of an Instrument", alias="entityId")
     display_name:  StrictStr = Field(...,alias="displayName", description="The display name of the entity.") 
-    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The properties of the entity. This field is empty until further notice.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(default=None, description="The properties of the entity. This field is empty until further notice.")
     scope:  Optional[StrictStr] = Field(None,alias="scope", description="The scope of the identifier") 
-    lusid_unique_id: Optional[LusidUniqueId] = Field(None, alias="lusidUniqueId")
-    identifiers: conlist(EntityIdentifier) = Field(..., description="The identifiers of the related entity in the relationship.")
+    lusid_unique_id: Optional[LusidUniqueId] = Field(default=None, alias="lusidUniqueId")
+    identifiers: List[EntityIdentifier] = Field(description="The identifiers of the related entity in the relationship.")
     href:  Optional[StrictStr] = Field(None,alias="href", description="The link to the entity.") 
     __properties = ["entityType", "entityId", "displayName", "properties", "scope", "lusidUniqueId", "identifiers", "href"]
 
@@ -129,3 +131,5 @@ class RelatedEntity(BaseModel):
             "href": obj.get("href")
         })
         return _obj
+
+RelatedEntity.update_forward_refs()