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

lusid/models/custom_entity_field.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, constr 
 
 class CustomEntityField(BaseModel):
     """
     CustomEntityField
     """
     name:  StrictStr = Field(...,alias="name", description="The name of the field in the custom entity type definition.") 
-    value: Optional[Any] = Field(None, description="The value for the field.")
-    effective_from: Optional[datetime] = Field(None, alias="effectiveFrom", description="The effective datetime from which the field's value is valid. For timeVariant fields, this defaults to the beginning of time.")
-    effective_until: Optional[datetime] = Field(None, alias="effectiveUntil", description="The effective datetime until which the field's value is valid. If not supplied, the value will be valid indefinitely or until the next “effectiveFrom” date of the field.")
+    value: Optional[Any] = Field(default=None, description="The value for the field.")
+    effective_from: Optional[datetime] = Field(default=None, description="The effective datetime from which the field's value is valid. For timeVariant fields, this defaults to the beginning of time.", alias="effectiveFrom")
+    effective_until: Optional[datetime] = Field(default=None, description="The effective datetime until which the field's value is valid. If not supplied, the value will be valid indefinitely or until the next “effectiveFrom” date of the field.", alias="effectiveUntil")
     __properties = ["name", "value", "effectiveFrom", "effectiveUntil"]
 
     class Config:
@@ -96,3 +98,5 @@ class CustomEntityField(BaseModel):
             "effective_until": obj.get("effectiveUntil")
         })
         return _obj
+
+CustomEntityField.update_forward_refs()

lusid/models/custom_entity_field_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, StrictBool, 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 CustomEntityFieldDefinition(BaseModel):
     """
@@ -29,7 +31,7 @@ class CustomEntityFieldDefinition(BaseModel):
     lifetime:  StrictStr = Field(...,alias="lifetime", description="Describes how the field’s values can change over time. The available values are: “Perpetual”, “TimeVariant”.") 
     type:  StrictStr = Field(...,alias="type", description="The value type for the field. Available values are: “String”, “Boolean”, “DateTime”, “Decimal”.") 
     collection_type:  Optional[StrictStr] = Field(None,alias="collectionType", description="The collection type for the field. Available values are: “Single”, “Array”. Null value defaults to “Single”") 
-    required: StrictBool = Field(..., description="Whether the field is required or not.")
+    required: StrictBool = Field(description="Whether the field is required or not.")
     description:  Optional[StrictStr] = Field(None,alias="description", description="An optional description for the field.") 
     __properties = ["name", "lifetime", "type", "collectionType", "required", "description"]
 
@@ -95,3 +97,5 @@ class CustomEntityFieldDefinition(BaseModel):
             "description": obj.get("description")
         })
         return _obj
+
+CustomEntityFieldDefinition.update_forward_refs()

lusid/models/custom_entity_id.py

@@ -17,9 +17,11 @@ 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, constr, validator 
 
 class CustomEntityId(BaseModel):
     """
@@ -28,8 +30,8 @@ class CustomEntityId(BaseModel):
     identifier_scope:  StrictStr = Field(...,alias="identifierScope", description="The scope the identifier resides in (the scope of the identifier property definition).") 
     identifier_type:  StrictStr = Field(...,alias="identifierType", description="What the identifier represents (the code of the identifier property definition).") 
     identifier_value:  StrictStr = Field(...,alias="identifierValue", description="The value of the identifier for this entity.") 
-    effective_from: Optional[datetime] = Field(None, alias="effectiveFrom", description="The effective datetime from which the identifier is valid.")
-    effective_until: Optional[datetime] = Field(None, alias="effectiveUntil", description="The effective datetime until which the identifier is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveFrom' datetime of the identifier.")
+    effective_from: Optional[datetime] = Field(default=None, description="The effective datetime from which the identifier is valid.", alias="effectiveFrom")
+    effective_until: Optional[datetime] = Field(default=None, description="The effective datetime until which the identifier is valid. If not supplied this will be valid indefinitely, or until the next 'effectiveFrom' datetime of the identifier.", alias="effectiveUntil")
     __properties = ["identifierScope", "identifierType", "identifierValue", "effectiveFrom", "effectiveUntil"]
 
     class Config:
@@ -93,3 +95,5 @@ class CustomEntityId(BaseModel):
             "effective_until": obj.get("effectiveUntil")
         })
         return _obj
+
+CustomEntityId.update_forward_refs()

lusid/models/custom_entity_properties.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.custom_entity_id import CustomEntityId
 from lusid.models.link import Link
 from lusid.models.model_property import ModelProperty
@@ -31,10 +33,10 @@ class CustomEntityProperties(BaseModel):
     """
     href:  StrictStr = Field(...,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
     entity_type:  StrictStr = Field(...,alias="entityType", description="The type of custom entity this is.") 
-    identifiers: conlist(CustomEntityId) = Field(..., description="The identifiers the custom entity will be upserted with.")
-    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The properties that decorate the custom entity.")
-    version: Version = Field(...)
-    links: Optional[conlist(Link)] = None
+    identifiers: List[CustomEntityId] = Field(description="The identifiers the custom entity will be upserted with.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(default=None, description="The properties that decorate the custom entity.")
+    version: Version
+    links: Optional[List[Link]] = None
     __properties = ["href", "entityType", "identifiers", "properties", "version", "links"]
 
     class Config:
@@ -128,3 +130,5 @@ class CustomEntityProperties(BaseModel):
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj
+
+CustomEntityProperties.update_forward_refs()

lusid/models/custom_entity_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, 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.custom_entity_field import CustomEntityField
 from lusid.models.custom_entity_id import CustomEntityId
 from lusid.models.model_property import ModelProperty
@@ -30,9 +32,9 @@ class CustomEntityRequest(BaseModel):
     """
     display_name:  StrictStr = Field(...,alias="displayName", description="A display label for the custom entity.") 
     description:  StrictStr = Field(...,alias="description", description="A description of the custom entity.") 
-    identifiers: conlist(CustomEntityId) = Field(..., description="The identifiers the custom entity will be upserted with.")
-    fields: Optional[conlist(CustomEntityField)] = Field(None, description="The fields that decorate the custom entity.")
-    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The properties that decorate the custom entity.")
+    identifiers: List[CustomEntityId] = Field(description="The identifiers the custom entity will be upserted with.")
+    fields: Optional[List[CustomEntityField]] = Field(default=None, description="The fields that decorate the custom entity.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(default=None, description="The properties that decorate the custom entity.")
     __properties = ["displayName", "description", "identifiers", "fields", "properties"]
 
     class Config:
@@ -122,3 +124,5 @@ class CustomEntityRequest(BaseModel):
             else None
         })
         return _obj
+
+CustomEntityRequest.update_forward_refs()

lusid/models/custom_entity_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.custom_entity_field import CustomEntityField
 from lusid.models.custom_entity_id import CustomEntityId
 from lusid.models.link import Link
@@ -34,15 +36,15 @@ class CustomEntityResponse(BaseModel):
     """
     href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
     entity_type:  StrictStr = Field(...,alias="entityType", description="The type of custom entity this is.") 
-    version: Version = Field(...)
-    staged_modifications: Optional[StagedModificationsInfo] = Field(None, alias="stagedModifications")
+    version: Version
+    staged_modifications: Optional[StagedModificationsInfo] = Field(default=None, alias="stagedModifications")
     display_name:  StrictStr = Field(...,alias="displayName", description="A display label for the custom entity.") 
     description:  Optional[StrictStr] = Field(None,alias="description", description="A description of the custom entity.") 
-    identifiers: conlist(CustomEntityId) = Field(..., description="The identifiers the custom entity will be upserted with.")
-    fields: conlist(CustomEntityField) = Field(..., description="The fields that decorate the custom entity.")
-    relationships: conlist(Relationship) = Field(..., description="A set of relationships associated to the custom entity.")
-    properties: Optional[Dict[str, ModelProperty]] = Field(None, description="The properties that decorate the custom entity.")
-    links: Optional[conlist(Link)] = None
+    identifiers: List[CustomEntityId] = Field(description="The identifiers the custom entity will be upserted with.")
+    fields: List[CustomEntityField] = Field(description="The fields that decorate the custom entity.")
+    relationships: List[Relationship] = Field(description="A set of relationships associated to the custom entity.")
+    properties: Optional[Dict[str, ModelProperty]] = Field(default=None, description="The properties that decorate the custom entity.")
+    links: Optional[List[Link]] = None
     __properties = ["href", "entityType", "version", "stagedModifications", "displayName", "description", "identifiers", "fields", "relationships", "properties", "links"]
 
     class Config:
@@ -168,3 +170,5 @@ class CustomEntityResponse(BaseModel):
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj
+
+CustomEntityResponse.update_forward_refs()

lusid/models/custom_entity_type.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.custom_entity_field_definition import CustomEntityFieldDefinition
 from lusid.models.link import Link
 from lusid.models.version import Version
@@ -33,9 +35,9 @@ class CustomEntityType(BaseModel):
     display_name:  StrictStr = Field(...,alias="displayName", description="A display label for the custom entity type.") 
     description:  Optional[StrictStr] = Field(None,alias="description", description="A description for the custom entity type.") 
     entity_type:  StrictStr = Field(...,alias="entityType", description="The identifier for the custom entity type, derived from the “entityTypeName” provided on creation.") 
-    field_schema: conlist(CustomEntityFieldDefinition) = Field(..., alias="fieldSchema", description="The description of the fields on the custom entity type.")
-    version: Version = Field(...)
-    links: Optional[conlist(Link)] = None
+    field_schema: List[CustomEntityFieldDefinition] = Field(description="The description of the fields on the custom entity type.", alias="fieldSchema")
+    version: Version
+    links: Optional[List[Link]] = None
     __properties = ["href", "entityTypeName", "displayName", "description", "entityType", "fieldSchema", "version", "links"]
 
     class Config:
@@ -124,3 +126,5 @@ class CustomEntityType(BaseModel):
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj
+
+CustomEntityType.update_forward_refs()

lusid/models/cut_label_definition.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.cut_local_time import CutLocalTime
 from lusid.models.link import Link
 from lusid.models.version import Version
@@ -31,11 +33,11 @@ class CutLabelDefinition(BaseModel):
     code:  Optional[StrictStr] = Field(None,alias="code", description="") 
     display_name:  Optional[StrictStr] = Field(None,alias="displayName", description="") 
     description:  Optional[StrictStr] = Field(None,alias="description", description="") 
-    cut_local_time: Optional[CutLocalTime] = Field(None, alias="cutLocalTime")
+    cut_local_time: Optional[CutLocalTime] = Field(default=None, alias="cutLocalTime")
     time_zone:  Optional[StrictStr] = Field(None,alias="timeZone", description="") 
     href:  Optional[StrictStr] = Field(None,alias="href") 
     version: Optional[Version] = None
-    links: Optional[conlist(Link)] = None
+    links: Optional[List[Link]] = None
     __properties = ["code", "displayName", "description", "cutLocalTime", "timeZone", "href", "version", "links"]
 
     class Config:
@@ -135,3 +137,5 @@ class CutLabelDefinition(BaseModel):
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj
+
+CutLabelDefinition.update_forward_refs()

lusid/models/cut_local_time.py

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

lusid/models/data_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, StrictBool, 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
 
 class DataDefinition(BaseModel):
     """
@@ -29,8 +31,8 @@ class DataDefinition(BaseModel):
     name:  Optional[StrictStr] = Field(None,alias="name", description="The name of the data item. This is the name that will appear") 
     data_type:  Optional[StrictStr] = Field(None,alias="dataType", description="A member of the set of possible data types, that all data passed under that key is expected to be of.  Currently limited to one of [string, integer, decimal, result0d].") 
     key_type:  Optional[StrictStr] = Field(None,alias="keyType", description="Is the item either a unique key for the dictionary, i.e. does it identify a unique index or conceptual 'row' within the list of dictionaries,  or a partial key or is it simply a data item within that dictionary. Must be one of [Unique,PartOfUnique,Leaf, CompositeLeaf]") 
-    allow_null: Optional[StrictBool] = Field(None, alias="allowNull", description="The path to the field must exist (unless AllowMissing is true) but the actual value is allowed to be null.")
-    allow_missing: Optional[StrictBool] = Field(None, alias="allowMissing", description="The path (or column) is allowed to be missing but if it is present it is not allowed to be null unless AllowNull is true.")
+    allow_null: Optional[StrictBool] = Field(default=None, description="The path to the field must exist (unless AllowMissing is true) but the actual value is allowed to be null.", alias="allowNull")
+    allow_missing: Optional[StrictBool] = Field(default=None, description="The path (or column) is allowed to be missing but if it is present it is not allowed to be null unless AllowNull is true.", alias="allowMissing")
     __properties = ["address", "name", "dataType", "keyType", "allowNull", "allowMissing"]
 
     class Config:
@@ -100,3 +102,5 @@ class DataDefinition(BaseModel):
             "allow_missing": obj.get("allowMissing")
         })
         return _obj
+
+DataDefinition.update_forward_refs()

lusid/models/data_map_key.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, 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 DataMapKey(BaseModel):
     """
@@ -87,3 +89,5 @@ class DataMapKey(BaseModel):
             "code": obj.get("code")
         })
         return _obj
+
+DataMapKey.update_forward_refs()

lusid/models/data_mapping.py

@@ -18,15 +18,17 @@ 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.data_definition import DataDefinition
 
 class DataMapping(BaseModel):
     """
     When importing data from an external source there are essentially three levels of interaction with LUSID.  (1) The data is a raw document that LUSID does not understand. You can store and retrieve it but it does not full interact with other documents inside LUSID  (2) The data has a map from fields and paths to 'properties' in LUSID. In essence, LUSID can then treat the data as weakly typed (decimal, string) data that can be returned through queries      and where various aggregation requests will then work.  (3) The data is fully translatable into LUSID and understood, in some sense, natively. This means that it can be used for context sensitive calculations such as pricing or risk calculations.  The data map object is designed to allow data to transition from step 1 to 2 and in some cases as an alternative for step 2 to 3.  # noqa: E501
     """
-    data_definitions: Optional[conlist(DataDefinition)] = Field(None, alias="dataDefinitions", description="A map from LUSID item keys to data definitions that define the names, types and degree of uniqueness of data provided to LUSID in structured data stores.")
+    data_definitions: Optional[List[DataDefinition]] = Field(default=None, description="A map from LUSID item keys to data definitions that define the names, types and degree of uniqueness of data provided to LUSID in structured data stores.", alias="dataDefinitions")
     __properties = ["dataDefinitions"]
 
     class Config:
@@ -88,3 +90,5 @@ class DataMapping(BaseModel):
             "data_definitions": [DataDefinition.from_dict(_item) for _item in obj.get("dataDefinitions")] if obj.get("dataDefinitions") is not None else None
         })
         return _obj
+
+DataMapping.update_forward_refs()

lusid/models/data_model_membership.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.membership import Membership
 from lusid.models.membership_and_status import MembershipAndStatus
 
@@ -27,8 +29,8 @@ class DataModelMembership(BaseModel):
     """
     DataModelMembership
     """
-    membership: conlist(Membership) = Field(..., description="The collection of data models this entity is a member of.")
-    current_model: Optional[MembershipAndStatus] = Field(None, alias="currentModel")
+    membership: List[Membership] = Field(description="The collection of data models this entity is a member of.")
+    current_model: Optional[MembershipAndStatus] = Field(default=None, alias="currentModel")
     __properties = ["membership", "currentModel"]
 
     class Config:
@@ -89,3 +91,5 @@ class DataModelMembership(BaseModel):
             "current_model": MembershipAndStatus.from_dict(obj.get("currentModel")) if obj.get("currentModel") is not None else None
         })
         return _obj
+
+DataModelMembership.update_forward_refs()

lusid/models/data_model_summary.py

@@ -18,22 +18,24 @@ import re  # noqa: F401
 import json
 
 
-from typing import Any, Dict, List, Optional
-from pydantic.v1 import StrictStr, Field, BaseModel, Field, StrictInt, 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.resource_id import ResourceId
 
 class DataModelSummary(BaseModel):
     """
     DataModelSummary
     """
-    id: ResourceId = Field(...)
+    id: ResourceId
     display_name:  StrictStr = Field(...,alias="displayName", description="The name of the Custom Data Model.") 
     description:  StrictStr = Field(...,alias="description", description="A description for the Custom Data Model.") 
     entity_type:  StrictStr = Field(...,alias="entityType", description="The entity type that the Custom Data Model binds to.") 
     type:  StrictStr = Field(...,alias="type", description="Either Root or Leaf or Intermediate.") 
-    precedence: StrictInt = Field(..., description="Where in the hierarchy this model sits.")
+    precedence: StrictInt = Field(description="Where in the hierarchy this model sits.")
     parent: Optional[ResourceId] = None
-    children: conlist(DataModelSummary) = Field(..., description="Child Custom Data Models that will inherit from this data model.")
+    children: List[DataModelSummary] = Field(description="Child Custom Data Models that will inherit from this data model.")
     __properties = ["id", "displayName", "description", "entityType", "type", "precedence", "parent", "children"]
 
     class Config:
@@ -103,3 +105,5 @@ class DataModelSummary(BaseModel):
             "children": [DataModelSummary.from_dict(_item) for _item in obj.get("children")] if obj.get("children") is not None else None
         })
         return _obj
+
+DataModelSummary.update_forward_refs()

lusid/models/data_quality_check_result.py

@@ -17,9 +17,11 @@ 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, StrictInt, StrictStr 
 from lusid.models.lusid_entity_result import LusidEntityResult
 
 class DataQualityCheckResult(BaseModel):
@@ -29,7 +31,7 @@ class DataQualityCheckResult(BaseModel):
     check_definition_scope:  Optional[StrictStr] = Field(None,alias="checkDefinitionScope", description="The scope of the check definition") 
     check_definition_code:  Optional[StrictStr] = Field(None,alias="checkDefinitionCode", description="The code of the check definition") 
     check_definition_display_name:  Optional[StrictStr] = Field(None,alias="checkDefinitionDisplayName", description="The display name of the check definition") 
-    check_run_as_at: Optional[datetime] = Field(None, alias="checkRunAsAt", description="The timestamp when the check was run")
+    check_run_as_at: Optional[datetime] = Field(default=None, description="The timestamp when the check was run", alias="checkRunAsAt")
     result_type:  Optional[StrictStr] = Field(None,alias="resultType", description="The type of result from the check") 
     rule_set_key:  Optional[StrictStr] = Field(None,alias="ruleSetKey", description="The key identifying the ruleset") 
     rule_set_display_name:  Optional[StrictStr] = Field(None,alias="ruleSetDisplayName", description="The display name of the ruleset") 
@@ -37,9 +39,9 @@ class DataQualityCheckResult(BaseModel):
     rule_display_name:  Optional[StrictStr] = Field(None,alias="ruleDisplayName", description="The display name of the rule (for RuleInvalid, RuleBreached, RuleBreachesOverLimit)") 
     rule_description:  Optional[StrictStr] = Field(None,alias="ruleDescription", description="The description of the rule (for RuleInvalid, RuleBreached, RuleBreachesOverLimit)") 
     rule_formula:  Optional[StrictStr] = Field(None,alias="ruleFormula", description="The formula of the rule (for RuleInvalid, RuleBreached, RuleBreachesOverLimit)") 
-    severity: Optional[StrictInt] = Field(None, description="The severity level")
-    lusid_entity: Optional[LusidEntityResult] = Field(None, alias="lusidEntity")
-    count_rule_breaches: Optional[StrictInt] = Field(None, alias="countRuleBreaches", description="The count of rule breaches (1 for RuleBreached, multiple for RuleBreachesOverLimit)")
+    severity: Optional[StrictInt] = Field(default=None, description="The severity level")
+    lusid_entity: Optional[LusidEntityResult] = Field(default=None, alias="lusidEntity")
+    count_rule_breaches: Optional[StrictInt] = Field(default=None, description="The count of rule breaches (1 for RuleBreached, multiple for RuleBreachesOverLimit)", alias="countRuleBreaches")
     error_detail:  Optional[StrictStr] = Field(None,alias="errorDetail", description="Error details (for RulesetInvalid, RuleInvalid)") 
     result_id:  Optional[StrictStr] = Field(None,alias="resultId", description="Unique identifier for the result in format: {{GUID of Check Definition}}-{{resultType}}-{{rulesetKey}}-{{ruleKey}}-{{entity GUID}}") 
     __properties = ["checkDefinitionScope", "checkDefinitionCode", "checkDefinitionDisplayName", "checkRunAsAt", "resultType", "ruleSetKey", "ruleSetDisplayName", "ruleKey", "ruleDisplayName", "ruleDescription", "ruleFormula", "severity", "lusidEntity", "countRuleBreaches", "errorDetail", "resultId"]
@@ -179,3 +181,5 @@ class DataQualityCheckResult(BaseModel):
             "result_id": obj.get("resultId")
         })
         return _obj
+
+DataQualityCheckResult.update_forward_refs()

lusid/models/data_scope.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.client import Client
 
 class DataScope(BaseModel):
@@ -86,3 +88,5 @@ class DataScope(BaseModel):
             "scope": obj.get("scope")
         })
         return _obj
+
+DataScope.update_forward_refs()

lusid/models/data_type.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, 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.i_unit_definition_dto import IUnitDefinitionDto
 from lusid.models.link import Link
 from lusid.models.reference_data import ReferenceData
@@ -32,18 +34,18 @@ class DataType(BaseModel):
     DataType
     """
     type_value_range:  StrictStr = Field(...,alias="typeValueRange", description="The available values are: Open, Closed") 
-    id: ResourceId = Field(...)
+    id: ResourceId
     display_name:  StrictStr = Field(...,alias="displayName") 
     description:  StrictStr = Field(...,alias="description") 
     value_type:  StrictStr = Field(...,alias="valueType", description="The available values are: String, Int, Decimal, DateTime, Boolean, Map, List, PropertyArray, Percentage, Code, Id, Uri, CurrencyAndAmount, TradePrice, Currency, MetricValue, ResourceId, ResultValue, CutLocalTime, DateOrCutLabel, UnindexedText") 
-    acceptable_values: Optional[conlist(StrictStr)] = Field(None, alias="acceptableValues")
+    acceptable_values: Optional[List[StrictStr]] = Field(default=None, alias="acceptableValues")
     unit_schema:  Optional[StrictStr] = Field(None,alias="unitSchema", description="The available values are: NoUnits, Basic, Iso4217Currency") 
-    acceptable_units: Optional[conlist(IUnitDefinitionDto)] = Field(None, alias="acceptableUnits")
-    reference_data: Optional[ReferenceData] = Field(None, alias="referenceData")
+    acceptable_units: Optional[List[IUnitDefinitionDto]] = Field(default=None, alias="acceptableUnits")
+    reference_data: Optional[ReferenceData] = Field(default=None, alias="referenceData")
     version: Optional[Version] = None
     href:  Optional[StrictStr] = Field(None,alias="href", description="The specific Uniform Resource Identifier (URI) for this resource at the requested effective and asAt datetime.") 
-    staged_modifications: Optional[StagedModificationsInfo] = Field(None, alias="stagedModifications")
-    links: Optional[conlist(Link)] = None
+    staged_modifications: Optional[StagedModificationsInfo] = Field(default=None, alias="stagedModifications")
+    links: Optional[List[Link]] = None
     __properties = ["typeValueRange", "id", "displayName", "description", "valueType", "acceptableValues", "unitSchema", "acceptableUnits", "referenceData", "version", "href", "stagedModifications", "links"]
 
     @validator('type_value_range')
@@ -96,14 +98,19 @@ class DataType(BaseModel):
                                     'SchedulerJobResponse', 
                                     'SleepResponse',
                                     'Library',
-                                    'LibraryResponse']:
+                                    'LibraryResponse',
+                                    'DayRegularity',
+                                    'RelativeMonthRegularity',
+                                    'SpecificMonthRegularity',
+                                    'WeekRegularity',
+                                    'YearRegularity']:
            return value
         
         # Only validate the 'type' property of the class
         if "type_value_range" != "type":
             return value
 
-        if value not in ('Open', 'Closed'):
+        if value not in ['Open', 'Closed']:
             raise ValueError("must be one of enum values ('Open', 'Closed')")
         return value
 
@@ -157,14 +164,19 @@ class DataType(BaseModel):
                                     'SchedulerJobResponse', 
                                     'SleepResponse',
                                     'Library',
-                                    'LibraryResponse']:
+                                    'LibraryResponse',
+                                    'DayRegularity',
+                                    'RelativeMonthRegularity',
+                                    'SpecificMonthRegularity',
+                                    'WeekRegularity',
+                                    'YearRegularity']:
            return value
         
         # Only validate the 'type' property of the class
         if "value_type" != "type":
             return value
 
-        if value not in ('String', 'Int', 'Decimal', 'DateTime', 'Boolean', 'Map', 'List', 'PropertyArray', 'Percentage', 'Code', 'Id', 'Uri', 'CurrencyAndAmount', 'TradePrice', 'Currency', 'MetricValue', 'ResourceId', 'ResultValue', 'CutLocalTime', 'DateOrCutLabel', 'UnindexedText'):
+        if value not in ['String', 'Int', 'Decimal', 'DateTime', 'Boolean', 'Map', 'List', 'PropertyArray', 'Percentage', 'Code', 'Id', 'Uri', 'CurrencyAndAmount', 'TradePrice', 'Currency', 'MetricValue', 'ResourceId', 'ResultValue', 'CutLocalTime', 'DateOrCutLabel', 'UnindexedText']:
             raise ValueError("must be one of enum values ('String', 'Int', 'Decimal', 'DateTime', 'Boolean', 'Map', 'List', 'PropertyArray', 'Percentage', 'Code', 'Id', 'Uri', 'CurrencyAndAmount', 'TradePrice', 'Currency', 'MetricValue', 'ResourceId', 'ResultValue', 'CutLocalTime', 'DateOrCutLabel', 'UnindexedText')")
         return value
 
@@ -218,7 +230,12 @@ class DataType(BaseModel):
                                     'SchedulerJobResponse', 
                                     'SleepResponse',
                                     'Library',
-                                    'LibraryResponse']:
+                                    'LibraryResponse',
+                                    'DayRegularity',
+                                    'RelativeMonthRegularity',
+                                    'SpecificMonthRegularity',
+                                    'WeekRegularity',
+                                    'YearRegularity']:
            return value
         
         # Only validate the 'type' property of the class
@@ -228,7 +245,7 @@ class DataType(BaseModel):
         if value is None:
             return value
 
-        if value not in ('NoUnits', 'Basic', 'Iso4217Currency'):
+        if value not in ['NoUnits', 'Basic', 'Iso4217Currency']:
             raise ValueError("must be one of enum values ('NoUnits', 'Basic', 'Iso4217Currency')")
         return value
 
@@ -337,3 +354,5 @@ class DataType(BaseModel):
             "links": [Link.from_dict(_item) for _item in obj.get("links")] if obj.get("links") is not None else None
         })
         return _obj
+
+DataType.update_forward_refs()