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

lusid/models/group_reconciliation_comparison_rule_string_value_map.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, 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
 
 class GroupReconciliationComparisonRuleStringValueMap(BaseModel):
     """
@@ -79,3 +81,5 @@ class GroupReconciliationComparisonRuleStringValueMap(BaseModel):
             "direction": obj.get("direction")
         })
         return _obj
+
+GroupReconciliationComparisonRuleStringValueMap.update_forward_refs()

lusid/models/group_reconciliation_comparison_rule_tolerance.py

@@ -18,15 +18,17 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Union
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictFloat, StrictInt, 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
 
 class GroupReconciliationComparisonRuleTolerance(BaseModel):
     """
     GroupReconciliationComparisonRuleTolerance
     """
     type:  StrictStr = Field(...,alias="type", description="The type of tolerance to allow. \"Relative\" | \"Absolute\"") 
-    value: Union[StrictFloat, StrictInt] = Field(..., description="The decimal value of how much tolerance to allow when comparing in relative (i.e percentage) or absolute terms depending on the ToleranceType specified")
+    value: Union[StrictFloat, StrictInt] = Field(description="The decimal value of how much tolerance to allow when comparing in relative (i.e percentage) or absolute terms depending on the ToleranceType specified")
     __properties = ["type", "value"]
 
     class Config:
@@ -77,3 +79,5 @@ class GroupReconciliationComparisonRuleTolerance(BaseModel):
             "value": obj.get("value")
         })
         return _obj
+
+GroupReconciliationComparisonRuleTolerance.update_forward_refs()

lusid/models/group_reconciliation_comparison_ruleset.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.group_reconciliation_aggregate_attribute_rule import GroupReconciliationAggregateAttributeRule
 from lusid.models.group_reconciliation_core_attribute_rule import GroupReconciliationCoreAttributeRule
 from lusid.models.link import Link
@@ -30,14 +32,14 @@ class GroupReconciliationComparisonRuleset(BaseModel):
     """
     GroupReconciliationComparisonRuleset
     """
-    id: ResourceId = Field(...)
+    id: ResourceId
     display_name:  StrictStr = Field(...,alias="displayName", description="The name of the ruleset") 
     reconciliation_type:  StrictStr = Field(...,alias="reconciliationType", description="The type of reconciliation to perform. \"Holding\" | \"Transaction\" | \"Valuation\"") 
-    core_attribute_rules: conlist(GroupReconciliationCoreAttributeRule) = Field(..., alias="coreAttributeRules", description="The core comparison rules")
-    aggregate_attribute_rules: conlist(GroupReconciliationAggregateAttributeRule) = Field(..., alias="aggregateAttributeRules", description="The aggregate comparison rules")
+    core_attribute_rules: List[GroupReconciliationCoreAttributeRule] = Field(description="The core comparison rules", alias="coreAttributeRules")
+    aggregate_attribute_rules: List[GroupReconciliationAggregateAttributeRule] = Field(description="The aggregate comparison rules", alias="aggregateAttributeRules")
     href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
     version: Optional[Version] = None
-    links: Optional[conlist(Link)] = None
+    links: Optional[List[Link]] = None
     __properties = ["id", "displayName", "reconciliationType", "coreAttributeRules", "aggregateAttributeRules", "href", "version", "links"]
 
     class Config:
@@ -131,3 +133,5 @@ class GroupReconciliationComparisonRuleset(BaseModel):
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj
+
+GroupReconciliationComparisonRuleset.update_forward_refs()

lusid/models/group_reconciliation_core_attribute_rule.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, StrictBool, 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.group_reconciliation_comparison_rule_string_value_map import GroupReconciliationComparisonRuleStringValueMap
 from lusid.models.group_reconciliation_core_comparison_rule_operand import GroupReconciliationCoreComparisonRuleOperand
 
@@ -27,10 +29,10 @@ class GroupReconciliationCoreAttributeRule(BaseModel):
     """
     GroupReconciliationCoreAttributeRule
     """
-    left: GroupReconciliationCoreComparisonRuleOperand = Field(...)
-    right: GroupReconciliationCoreComparisonRuleOperand = Field(...)
-    allowable_string_mappings: Optional[conlist(GroupReconciliationComparisonRuleStringValueMap)] = Field(None, alias="allowableStringMappings", description="The string mappings to use when comparing")
-    is_comparison_case_sensitive: StrictBool = Field(..., alias="isComparisonCaseSensitive", description="Whether the compare keys and strings mappings case sensitive or not")
+    left: GroupReconciliationCoreComparisonRuleOperand
+    right: GroupReconciliationCoreComparisonRuleOperand
+    allowable_string_mappings: Optional[List[GroupReconciliationComparisonRuleStringValueMap]] = Field(default=None, description="The string mappings to use when comparing", alias="allowableStringMappings")
+    is_comparison_case_sensitive: StrictBool = Field(description="Whether the compare keys and strings mappings case sensitive or not", alias="isComparisonCaseSensitive")
     __properties = ["left", "right", "allowableStringMappings", "isComparisonCaseSensitive"]
 
     class Config:
@@ -101,3 +103,5 @@ class GroupReconciliationCoreAttributeRule(BaseModel):
             "is_comparison_case_sensitive": obj.get("isComparisonCaseSensitive")
         })
         return _obj
+
+GroupReconciliationCoreAttributeRule.update_forward_refs()

lusid/models/group_reconciliation_core_attribute_values.py

@@ -18,16 +18,18 @@ 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.comparison_attribute_value_pair import ComparisonAttributeValuePair
 
 class GroupReconciliationCoreAttributeValues(BaseModel):
     """
     GroupReconciliationCoreAttributeValues
     """
-    left_core_attributes: conlist(ComparisonAttributeValuePair) = Field(..., alias="leftCoreAttributes", description="Core attribute names and values for the left hand entity being reconciled.")
-    right_core_attributes: conlist(ComparisonAttributeValuePair) = Field(..., alias="rightCoreAttributes", description="Core attribute names and values for the right hand entity being reconciled.")
+    left_core_attributes: List[ComparisonAttributeValuePair] = Field(description="Core attribute names and values for the left hand entity being reconciled.", alias="leftCoreAttributes")
+    right_core_attributes: List[ComparisonAttributeValuePair] = Field(description="Core attribute names and values for the right hand entity being reconciled.", alias="rightCoreAttributes")
     __properties = ["leftCoreAttributes", "rightCoreAttributes"]
 
     class Config:
@@ -92,3 +94,5 @@ class GroupReconciliationCoreAttributeValues(BaseModel):
             "right_core_attributes": [ComparisonAttributeValuePair.from_dict(_item) for _item in obj.get("rightCoreAttributes")] if obj.get("rightCoreAttributes") is not None else None
         })
         return _obj
+
+GroupReconciliationCoreAttributeValues.update_forward_refs()

lusid/models/group_reconciliation_core_comparison_rule_operand.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, 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
 
 class GroupReconciliationCoreComparisonRuleOperand(BaseModel):
     """
@@ -77,3 +79,5 @@ class GroupReconciliationCoreComparisonRuleOperand(BaseModel):
             "operation": obj.get("operation")
         })
         return _obj
+
+GroupReconciliationCoreComparisonRuleOperand.update_forward_refs()

lusid/models/group_reconciliation_date_pair.py

@@ -17,16 +17,18 @@ 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 
 
 class GroupReconciliationDatePair(BaseModel):
     """
     GroupReconciliationDatePair
     """
-    effective_at: Optional[datetime] = Field(None, alias="effectiveAt", description="The effective at date for the reconciliation")
-    as_at: Optional[datetime] = Field(None, alias="asAt", description="The as at date for the reconciliation")
+    effective_at: Optional[datetime] = Field(default=None, description="The effective at date for the reconciliation", alias="effectiveAt")
+    as_at: Optional[datetime] = Field(default=None, description="The as at date for the reconciliation", alias="asAt")
     __properties = ["effectiveAt", "asAt"]
 
     class Config:
@@ -87,3 +89,5 @@ class GroupReconciliationDatePair(BaseModel):
             "as_at": obj.get("asAt")
         })
         return _obj
+
+GroupReconciliationDatePair.update_forward_refs()

lusid/models/group_reconciliation_dates.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel 
+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.group_reconciliation_date_pair import GroupReconciliationDatePair
 
 class GroupReconciliationDates(BaseModel):
@@ -84,3 +86,5 @@ class GroupReconciliationDates(BaseModel):
             "right": GroupReconciliationDatePair.from_dict(obj.get("right")) if obj.get("right") is not None else None
         })
         return _obj
+
+GroupReconciliationDates.update_forward_refs()

lusid/models/group_reconciliation_definition.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, 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.break_code_source import BreakCodeSource
 from lusid.models.group_reconciliation_definition_comparison_ruleset_ids import GroupReconciliationDefinitionComparisonRulesetIds
 from lusid.models.group_reconciliation_definition_currencies import GroupReconciliationDefinitionCurrencies
@@ -37,13 +39,13 @@ class GroupReconciliationDefinition(BaseModel):
     id: Optional[ResourceId] = None
     display_name:  Optional[StrictStr] = Field(None,alias="displayName", description="The name of the Group Reconciliation Definition") 
     description:  Optional[StrictStr] = Field(None,alias="description", description="The description of the Group Reconciliation Definition") 
-    portfolio_entity_ids: Optional[GroupReconciliationDefinitionPortfolioEntityIds] = Field(None, alias="portfolioEntityIds")
-    recipe_ids: Optional[GroupReconciliationDefinitionRecipeIds] = Field(None, alias="recipeIds")
+    portfolio_entity_ids: Optional[GroupReconciliationDefinitionPortfolioEntityIds] = Field(default=None, alias="portfolioEntityIds")
+    recipe_ids: Optional[GroupReconciliationDefinitionRecipeIds] = Field(default=None, alias="recipeIds")
     currencies: Optional[GroupReconciliationDefinitionCurrencies] = None
-    transaction_date_windows: Optional[TransactionDateWindows] = Field(None, alias="transactionDateWindows")
-    comparison_ruleset_ids: Optional[GroupReconciliationDefinitionComparisonRulesetIds] = Field(None, alias="comparisonRulesetIds")
-    break_code_source: Optional[BreakCodeSource] = Field(None, alias="breakCodeSource")
-    primary_schedule: Optional[PrimarySchedule] = Field(None, alias="primarySchedule")
+    transaction_date_windows: Optional[TransactionDateWindows] = Field(default=None, alias="transactionDateWindows")
+    comparison_ruleset_ids: Optional[GroupReconciliationDefinitionComparisonRulesetIds] = Field(default=None, alias="comparisonRulesetIds")
+    break_code_source: Optional[BreakCodeSource] = Field(default=None, alias="breakCodeSource")
+    primary_schedule: Optional[PrimarySchedule] = Field(default=None, alias="primarySchedule")
     href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
     version: Optional[Version] = None
     __properties = ["id", "displayName", "description", "portfolioEntityIds", "recipeIds", "currencies", "transactionDateWindows", "comparisonRulesetIds", "breakCodeSource", "primarySchedule", "href", "version"]
@@ -148,3 +150,5 @@ class GroupReconciliationDefinition(BaseModel):
             "version": Version.from_dict(obj.get("version")) if obj.get("version") is not None else None
         })
         return _obj
+
+GroupReconciliationDefinition.update_forward_refs()

lusid/models/group_reconciliation_definition_comparison_ruleset_ids.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
 from lusid.models.resource_id import ResourceId
 
 class GroupReconciliationDefinitionComparisonRulesetIds(BaseModel):
     """
     GroupReconciliationDefinitionComparisonRulesetIds
     """
-    transaction_reconciliation: Optional[ResourceId] = Field(None, alias="transactionReconciliation")
-    holding_reconciliation: Optional[ResourceId] = Field(None, alias="holdingReconciliation")
-    valuation_reconciliation: Optional[ResourceId] = Field(None, alias="valuationReconciliation")
+    transaction_reconciliation: Optional[ResourceId] = Field(default=None, alias="transactionReconciliation")
+    holding_reconciliation: Optional[ResourceId] = Field(default=None, alias="holdingReconciliation")
+    valuation_reconciliation: Optional[ResourceId] = Field(default=None, alias="valuationReconciliation")
     __properties = ["transactionReconciliation", "holdingReconciliation", "valuationReconciliation"]
 
     class Config:
@@ -89,3 +91,5 @@ class GroupReconciliationDefinitionComparisonRulesetIds(BaseModel):
             "valuation_reconciliation": ResourceId.from_dict(obj.get("valuationReconciliation")) if obj.get("valuationReconciliation") is not None else None
         })
         return _obj
+
+GroupReconciliationDefinitionComparisonRulesetIds.update_forward_refs()

lusid/models/group_reconciliation_definition_currencies.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, 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
 
 class GroupReconciliationDefinitionCurrencies(BaseModel):
     """
@@ -77,3 +79,5 @@ class GroupReconciliationDefinitionCurrencies(BaseModel):
             "right": obj.get("right")
         })
         return _obj
+
+GroupReconciliationDefinitionCurrencies.update_forward_refs()

lusid/models/group_reconciliation_definition_portfolio_entity_ids.py

@@ -18,16 +18,18 @@ 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.portfolio_entity_id import PortfolioEntityId
 
 class GroupReconciliationDefinitionPortfolioEntityIds(BaseModel):
     """
     GroupReconciliationDefinitionPortfolioEntityIds
     """
-    left: conlist(PortfolioEntityId) = Field(..., description="Portfolio Entity Id of the left side of a reconciliation")
-    right: conlist(PortfolioEntityId) = Field(..., description="Portfolio Entity Id of the right side of a reconciliation")
+    left: List[PortfolioEntityId] = Field(description="Portfolio Entity Id of the left side of a reconciliation")
+    right: List[PortfolioEntityId] = Field(description="Portfolio Entity Id of the right side of a reconciliation")
     __properties = ["left", "right"]
 
     class Config:
@@ -92,3 +94,5 @@ class GroupReconciliationDefinitionPortfolioEntityIds(BaseModel):
             "right": [PortfolioEntityId.from_dict(_item) for _item in obj.get("right")] if obj.get("right") is not None else None
         })
         return _obj
+
+GroupReconciliationDefinitionPortfolioEntityIds.update_forward_refs()

lusid/models/group_reconciliation_definition_recipe_ids.py

@@ -18,16 +18,18 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-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.resource_id import ResourceId
 
 class GroupReconciliationDefinitionRecipeIds(BaseModel):
     """
     GroupReconciliationDefinitionRecipeIds
     """
-    left: ResourceId = Field(...)
-    right: ResourceId = Field(...)
+    left: ResourceId
+    right: ResourceId
     __properties = ["left", "right"]
 
     class Config:
@@ -84,3 +86,5 @@ class GroupReconciliationDefinitionRecipeIds(BaseModel):
             "right": ResourceId.from_dict(obj.get("right")) if obj.get("right") is not None else None
         })
         return _obj
+
+GroupReconciliationDefinitionRecipeIds.update_forward_refs()

lusid/models/group_reconciliation_instance_id.py

@@ -18,8 +18,10 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, 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
 
 class GroupReconciliationInstanceId(BaseModel):
     """
@@ -77,3 +79,5 @@ class GroupReconciliationInstanceId(BaseModel):
             "instance_id_value": obj.get("instanceIdValue")
         })
         return _obj
+
+GroupReconciliationInstanceId.update_forward_refs()

lusid/models/group_reconciliation_result_statuses.py

@@ -18,20 +18,22 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictInt 
+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
 
 class GroupReconciliationResultStatuses(BaseModel):
     """
     GroupReconciliationResultStatuses
     """
-    count_new: StrictInt = Field(..., alias="countNew", description="The number of comparison results of resultStatus \"New\" with this instanceId and reconciliationType")
-    link_new: Link = Field(..., alias="linkNew")
-    count_confirmed: StrictInt = Field(..., alias="countConfirmed", description="The number of comparison results of resultStatus \"Confirmed\" with this instanceId and reconciliationType")
-    link_confirmed: Link = Field(..., alias="linkConfirmed")
-    count_changed: StrictInt = Field(..., alias="countChanged", description="The number of comparison results of resultStatus \"Changed\" with this instanceId and reconciliationType")
-    link_changed: Link = Field(..., alias="linkChanged")
+    count_new: StrictInt = Field(description="The number of comparison results of resultStatus \"New\" with this instanceId and reconciliationType", alias="countNew")
+    link_new: Link = Field(alias="linkNew")
+    count_confirmed: StrictInt = Field(description="The number of comparison results of resultStatus \"Confirmed\" with this instanceId and reconciliationType", alias="countConfirmed")
+    link_confirmed: Link = Field(alias="linkConfirmed")
+    count_changed: StrictInt = Field(description="The number of comparison results of resultStatus \"Changed\" with this instanceId and reconciliationType", alias="countChanged")
+    link_changed: Link = Field(alias="linkChanged")
     __properties = ["countNew", "linkNew", "countConfirmed", "linkConfirmed", "countChanged", "linkChanged"]
 
     class Config:
@@ -95,3 +97,5 @@ class GroupReconciliationResultStatuses(BaseModel):
             "link_changed": Link.from_dict(obj.get("linkChanged")) if obj.get("linkChanged") is not None else None
         })
         return _obj
+
+GroupReconciliationResultStatuses.update_forward_refs()

lusid/models/group_reconciliation_result_types.py

@@ -18,22 +18,24 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictInt 
+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
 
 class GroupReconciliationResultTypes(BaseModel):
     """
     GroupReconciliationResultTypes
     """
-    count_match: StrictInt = Field(..., alias="countMatch", description="The number of comparison results of resultType \"Match\" with this instanceId and reconciliationType")
-    link_matches: Link = Field(..., alias="linkMatches")
-    count_partial_match: StrictInt = Field(..., alias="countPartialMatch", description="The number of comparison results of resultType \"PartialMatch\" with this instanceId and reconciliationType")
-    link_partial_matches: Link = Field(..., alias="linkPartialMatches")
-    count_break: StrictInt = Field(..., alias="countBreak", description="The number of comparison results of resultType \"Break\" with this instanceId and reconciliationType")
-    link_breaks: Link = Field(..., alias="linkBreaks")
-    count_resolved: StrictInt = Field(..., alias="countResolved", description="The number of comparison results of resultType \"Resolved\" with this instanceId and reconciliationType")
-    link_resolved: Link = Field(..., alias="linkResolved")
+    count_match: StrictInt = Field(description="The number of comparison results of resultType \"Match\" with this instanceId and reconciliationType", alias="countMatch")
+    link_matches: Link = Field(alias="linkMatches")
+    count_partial_match: StrictInt = Field(description="The number of comparison results of resultType \"PartialMatch\" with this instanceId and reconciliationType", alias="countPartialMatch")
+    link_partial_matches: Link = Field(alias="linkPartialMatches")
+    count_break: StrictInt = Field(description="The number of comparison results of resultType \"Break\" with this instanceId and reconciliationType", alias="countBreak")
+    link_breaks: Link = Field(alias="linkBreaks")
+    count_resolved: StrictInt = Field(description="The number of comparison results of resultType \"Resolved\" with this instanceId and reconciliationType", alias="countResolved")
+    link_resolved: Link = Field(alias="linkResolved")
     __properties = ["countMatch", "linkMatches", "countPartialMatch", "linkPartialMatches", "countBreak", "linkBreaks", "countResolved", "linkResolved"]
 
     class Config:
@@ -102,3 +104,5 @@ class GroupReconciliationResultTypes(BaseModel):
             "link_resolved": Link.from_dict(obj.get("linkResolved")) if obj.get("linkResolved") is not None else None
         })
         return _obj
+
+GroupReconciliationResultTypes.update_forward_refs()

lusid/models/group_reconciliation_review_statuses.py

@@ -18,22 +18,24 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictInt 
+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
 
 class GroupReconciliationReviewStatuses(BaseModel):
     """
     GroupReconciliationReviewStatuses
     """
-    count_pending: StrictInt = Field(..., alias="countPending", description="The number of comparison results of reviewStatus \"Pending\" with this instanceId and reconciliationType")
-    link_pending: Link = Field(..., alias="linkPending")
-    count_reviewed: StrictInt = Field(..., alias="countReviewed", description="The number of comparison results of reviewStatus \"Reviewed\" with this instanceId and reconciliationType")
-    link_reviewed: Link = Field(..., alias="linkReviewed")
-    count_matched: StrictInt = Field(..., alias="countMatched", description="The number of comparison results of reviewStatus \"Matched\" with this instanceId and reconciliationType")
-    link_matched: Link = Field(..., alias="linkMatched")
-    count_invalid: StrictInt = Field(..., alias="countInvalid", description="The number of comparison results of reviewStatus \"Invalid\" with this instanceId and reconciliationType")
-    link_invalid: Link = Field(..., alias="linkInvalid")
+    count_pending: StrictInt = Field(description="The number of comparison results of reviewStatus \"Pending\" with this instanceId and reconciliationType", alias="countPending")
+    link_pending: Link = Field(alias="linkPending")
+    count_reviewed: StrictInt = Field(description="The number of comparison results of reviewStatus \"Reviewed\" with this instanceId and reconciliationType", alias="countReviewed")
+    link_reviewed: Link = Field(alias="linkReviewed")
+    count_matched: StrictInt = Field(description="The number of comparison results of reviewStatus \"Matched\" with this instanceId and reconciliationType", alias="countMatched")
+    link_matched: Link = Field(alias="linkMatched")
+    count_invalid: StrictInt = Field(description="The number of comparison results of reviewStatus \"Invalid\" with this instanceId and reconciliationType", alias="countInvalid")
+    link_invalid: Link = Field(alias="linkInvalid")
     __properties = ["countPending", "linkPending", "countReviewed", "linkReviewed", "countMatched", "linkMatched", "countInvalid", "linkInvalid"]
 
     class Config:
@@ -102,3 +104,5 @@ class GroupReconciliationReviewStatuses(BaseModel):
             "link_invalid": Link.from_dict(obj.get("linkInvalid")) if obj.get("linkInvalid") is not None else None
         })
         return _obj
+
+GroupReconciliationReviewStatuses.update_forward_refs()

lusid/models/group_reconciliation_run_details.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, 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
 
 class GroupReconciliationRunDetails(BaseModel):
     """
@@ -82,3 +84,5 @@ class GroupReconciliationRunDetails(BaseModel):
             "error_detail": obj.get("errorDetail")
         })
         return _obj
+
+GroupReconciliationRunDetails.update_forward_refs()

lusid/models/group_reconciliation_run_request.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, 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.group_reconciliation_dates import GroupReconciliationDates
 
 class GroupReconciliationRunRequest(BaseModel):
@@ -27,7 +29,7 @@ class GroupReconciliationRunRequest(BaseModel):
     GroupReconciliationRunRequest
     """
     instance_id:  StrictStr = Field(...,alias="instanceId", description="Reconciliation run Id. Consists of run type (manual or workflow) and identifier.") 
-    dates_to_reconcile: Optional[GroupReconciliationDates] = Field(None, alias="datesToReconcile")
+    dates_to_reconcile: Optional[GroupReconciliationDates] = Field(default=None, alias="datesToReconcile")
     __properties = ["instanceId", "datesToReconcile"]
 
     class Config:
@@ -81,3 +83,5 @@ class GroupReconciliationRunRequest(BaseModel):
             "dates_to_reconcile": GroupReconciliationDates.from_dict(obj.get("datesToReconcile")) if obj.get("datesToReconcile") is not None else None
         })
         return _obj
+
+GroupReconciliationRunRequest.update_forward_refs()

lusid/models/group_reconciliation_run_response.py

@@ -18,15 +18,17 @@ 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.group_reconciliation_summary import GroupReconciliationSummary
 
 class GroupReconciliationRunResponse(BaseModel):
     """
     GroupReconciliationRunResponse
     """
-    reconciliation_summaries: conlist(GroupReconciliationSummary) = Field(..., alias="reconciliationSummaries", description="One summary record for each of the \"Holding\" | \"Transaction\" | \"Valuation\" reconciliations performed")
+    reconciliation_summaries: List[GroupReconciliationSummary] = Field(description="One summary record for each of the \"Holding\" | \"Transaction\" | \"Valuation\" reconciliations performed", alias="reconciliationSummaries")
     __properties = ["reconciliationSummaries"]
 
     class Config:
@@ -83,3 +85,5 @@ class GroupReconciliationRunResponse(BaseModel):
             "reconciliation_summaries": [GroupReconciliationSummary.from_dict(_item) for _item in obj.get("reconciliationSummaries")] if obj.get("reconciliationSummaries") is not None else None
         })
         return _obj
+
+GroupReconciliationRunResponse.update_forward_refs()