feat: Support record value types

codegen/lib/layouts/resources.ts

@@ -120,6 +120,25 @@ const mergeOccurrences = (occurrences: Property[], path: string): Property => {
     return merged
   }
 
+  if (first.format === 'record' && 'valueTypes' in first) {
+    const valueTypes = occurrences.some(
+      (occurrence) =>
+        !('valueTypes' in occurrence) || occurrence.valueTypes == null,
+    )
+      ? undefined
+      : [
+          ...new Set(
+            occurrences.flatMap((occurrence) =>
+              'valueTypes' in occurrence ? (occurrence.valueTypes ?? []) : [],
+            ),
+          ),
+        ]
+    const merged = { ...first, ...docs }
+    if (valueTypes == null) delete merged.valueTypes
+    else merged.valueTypes = valueTypes
+    return merged
+  }
+
   if (first.format === 'object') {
     return {
       ...first,

codegen/lib/python-type.ts

@@ -9,6 +9,10 @@ type ListItemFormat = Extract<
   { format: 'list' }
 >['itemFormat']
 
+type RecordValueType = NonNullable<
+  Extract<Parameter, { format: 'record' }>['valueTypes']
+>[number]
+
 export const mapParameterToPythonType = (parameter: Parameter): string => {
   if (parameter.format === 'list') {
     return `List[${mapListItemFormatToPythonType(parameter.itemFormat)}]`
@@ -22,6 +26,10 @@ export const mapParameterToPythonType = (parameter: Parameter): string => {
     return mapBooleanToPythonType(parameter.values)
   }
 
+  if (parameter.format === 'record') {
+    return mapRecordToPythonType(parameter.valueTypes)
+  }
+
   return mapScalarFormatToPythonType(parameter.format)
 }
 
@@ -65,6 +73,10 @@ export const mapRequiredPropertyToPythonType = (
     return 'List[Dict[str, Any]]'
   }
 
+  if (property.format === 'record' && 'valueTypes' in property) {
+    return mapRecordToPythonType(property.valueTypes)
+  }
+
   if (property.format === 'object' && nestedClassName != null) {
     return nestedClassName
   }
@@ -77,6 +89,36 @@ const mapBooleanToPythonType = (values?: boolean[]): string =>
     ? 'bool'
     : `Literal[${values.map((value) => (value ? 'True' : 'False')).join(', ')}]`
 
+const mapRecordToPythonType = (valueTypes?: RecordValueType[]): string => {
+  const types = valueTypes?.map(mapJsonSchemaTypeToPythonType) ?? []
+  const valueType =
+    types.length === 0
+      ? 'Any'
+      : types.length === 1
+        ? (types[0] ?? 'Any')
+        : `Union[${types.join(', ')}]`
+  return `Dict[str, ${valueType}]`
+}
+
+const mapJsonSchemaTypeToPythonType = (type: RecordValueType): string => {
+  switch (type) {
+    case 'string':
+      return 'str'
+    case 'number':
+      return 'float'
+    case 'integer':
+      return 'int'
+    case 'boolean':
+      return 'bool'
+    case 'object':
+      return 'Dict[str, Any]'
+    case 'array':
+      return 'List[Any]'
+    default:
+      throw new Error(`Unsupported JSON Schema type: ${type}`)
+  }
+}
+
 const mapScalarFormatToPythonType = (format: ScalarFormat): string => {
   switch (format) {
     case 'string':

package.json

@@ -28,7 +28,7 @@
     }
   },
   "devDependencies": {
-    "@seamapi/blueprint": "^1.6.0",
+    "@seamapi/blueprint": "^1.7.0",
     "@seamapi/fake-seam-connect": "1.86.0",
     "@seamapi/smith": "^1.1.0",
     "@seamapi/types": "1.1001.0",

test/resource_types_test.py

@@ -1,8 +1,14 @@
 # mypy: warn_unused_ignores=True
 
-from typing import Literal, assert_type
+from typing import Any, Dict, Literal, Union, assert_type
 
-from seam.resources import AccessCode, ActionAttempt, UnmanagedAccessCode
+from seam.resources import (
+    AccessCode,
+    ActionAttempt,
+    Device,
+    SeamEvent,
+    UnmanagedAccessCode,
+)
 
 
 def _assert_access_code_narrowing(
@@ -25,11 +31,21 @@ def _assert_boolean_shapes(
     assert_type(credential.is_managed, Literal[True, False])
 
 
+def _assert_record_value_types(device: Device, event: SeamEvent) -> None:
+    assert_type(device.custom_metadata, Dict[str, Union[str, bool]])
+    assert_type(
+        event.connected_account_custom_metadata,
+        Dict[str, Union[str, bool]] | None,
+    )
+    assert_type(event.minut_metadata, Dict[str, Any] | None)
+
+
 def _assert_opposite_literal_is_rejected(code: UnmanagedAccessCode) -> None:
     code.is_managed = True  # type: ignore[assignment]
 
 
 def test_access_code_resources_narrow_on_is_managed():
     assert callable(_assert_access_code_narrowing)
     assert callable(_assert_boolean_shapes)
+    assert callable(_assert_record_value_types)
     assert callable(_assert_opposite_literal_is_rejected)