@api-client/core 0.18.53 → 0.18.55

package/data/models/example-generator-api.json

@@ -42065,10 +42065,10 @@
 "@id": "#191"
 },
 {
-"@id": "#194"
+"@id": "#197"
 },
 {
-"@id": "#197"
+"@id": "#194"
 },
 {
 "@id": "#200"
@@ -42816,10 +42816,10 @@
 "@id": "#213"
 },
 {
-"@id": "#216"
+"@id": "#219"
 },
 {
-"@id": "#219"
+"@id": "#216"
 }
 ],
 "doc:root": false,
@@ -43457,7 +43457,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
+"doc:raw": "code: '5'\ndescription: 'Limited company'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -43478,7 +43478,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "code: '5'\ndescription: 'Limited company'\n",
+"doc:raw": "addressType: 'REGISTERED-OFFICE-ADDRESS'\nstreetName: 'UITBREIDINGSTRAAT'\nhouseNumber: '84'\nhouseNumberAddition: '/1'\npostalCode: '2600'\ncity: 'BERCHEM (ANTWERPEN)'\ncountry: 'Belgium'\ncountryCode: 'BE'\nfullFormatedAddress: \"UITBREIDINGSTRAAT 84 /1, 2600 BERCHEM (ANTWERPEN), BELIUM\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44274,7 +44274,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@company.be'\n",
+"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44295,7 +44295,7 @@
 "doc:ExternalDomainElement",
 "doc:DomainElement"
 ],
-"doc:raw": "type: \"GENERAL\"\nvalue: \"www.company.be\"\n",
+"doc:raw": "-\n  type: 'GENERAL'\n  value: 'info@company.be'\n-\n  type: 'IT_DEPT'\n  value: 'it-service@company.be'\n",
 "core:mediaType": "application/yaml",
 "sourcemaps:sources": [
 {
@@ -44761,12 +44761,12 @@
 {
 "@id": "#196/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#196",
-"sourcemaps:value": "[(1,0)-(10,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#199/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#199",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(10,0)]"
 },
 {
 "@id": "#202/source-map/lexical/element_0",
@@ -45126,12 +45126,12 @@
 {
 "@id": "#218/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#218",
-"sourcemaps:value": "[(1,0)-(7,0)]"
+"sourcemaps:value": "[(1,0)-(3,0)]"
 },
 {
 "@id": "#221/source-map/lexical/element_0",
 "sourcemaps:element": "amf://id#221",
-"sourcemaps:value": "[(1,0)-(3,0)]"
+"sourcemaps:value": "[(1,0)-(7,0)]"
 },
 {
 "@id": "#338/source-map/synthesized-field/element_1",

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@api-client/core",
   "description": "The API Client's core client library. Works in NodeJS and in a ES enabled browser.",
-  "version": "0.18.53",
+  "version": "0.18.55",
   "license": "Apache-2.0",
   "exports": {
     "./browser.js": {

package/src/modeling/Semantics.ts

@@ -15,6 +15,10 @@ export enum SemanticType {
    * Designates a Data Entity that represents users of the system.
    */
   User = 'Semantic#User',
+  /**
+   * Designates a Data Entity that represents a physical address.
+   */
+  Address = 'Semantic#Address',
 
   //
   // Property-Level Semantics
@@ -197,10 +201,33 @@ export enum SemanticType {
   Derived = 'Semantic#Derived',
   /**
    * Annotates a field that should automatically receive the client's IP address.
-   * The runtime automatically populates this field with the request's IP address
    * when creating or updating records, providing audit trail and geolocation capabilities.
    */
   ClientIPAddress = 'Semantic#ClientIPAddress',
+  /**
+   * Designates a Data Property as the street address (e.g., "123 Main St").
+   */
+  StreetAddress = 'Semantic#StreetAddress',
+  /**
+   * This is a single semantic used for any additional lines (Unit, Suite, Apartment, Floor).
+   */
+  StreetAddressSupplemental = 'Semantic#StreetAddressSupplemental',
+  /**
+   * Designates a Data Property as the city or locality.
+   */
+  City = 'Semantic#City',
+  /**
+   * Designates a Data Property as the postal or zip code.
+   */
+  PostalCode = 'Semantic#PostalCode',
+  /**
+   * Designates a Data Property as the country.
+   */
+  Country = 'Semantic#Country',
+  /**
+   * Designates a Data Property as the state, province, or region.
+   */
+  Region = 'Semantic#Region',
 
   //
   // Association-Level Semantics
@@ -271,10 +298,6 @@ export enum SemanticCategory {
    * Business-specific data like pricing, inventory, status
    */
   Business = 'Business Data',
-  /**
-   * Contact information and communication
-   */
-  Contact = 'Contact Information',
   /**
    * Organization, categorization, and tagging
    */
@@ -283,6 +306,10 @@ export enum SemanticCategory {
    * Location and geographical data
    */
   Location = 'Location & Geography',
+  /**
+   * Contact information and communication
+   */
+  Contact = 'Contact Information',
   /**
    * Calculated and derived values
    */
@@ -792,6 +819,106 @@ export const DataSemantics: Record<SemanticType, DataSemantic> = {
       priority: 80,
     },
   },
+
+  //
+  // Contact & Address
+  //
+
+  [SemanticType.Address]: {
+    id: SemanticType.Address,
+    displayName: 'Address Entity',
+    scope: SemanticScope.Entity,
+    description: 'Physical address entity',
+    category: SemanticCategory.Contact,
+    // For now, the Address won't have configuration, but future-wise:
+    //  - autoGeocode (boolean): If true, the runtime automatically generates latitude and longitude for the record whenever the address properties change.
+    //  - validationProvider (enum): Options like None, GoogleMaps, or Loqate. This determines if the API returns an error for non-existent addresses.
+    //  - strictness (enum): Lax (accept anything) vs. Strict (reject if not deliverable).
+    hasConfig: false,
+    runtime: {
+      timing: SemanticTiming.None,
+      operations: [],
+    },
+  },
+  [SemanticType.StreetAddress]: {
+    id: SemanticType.StreetAddress,
+    displayName: 'Street Address',
+    scope: SemanticScope.Property,
+    description: 'Street address line',
+    category: SemanticCategory.Contact,
+    applicableDataTypes: ['string'],
+    hasConfig: false,
+    runtime: {
+      timing: SemanticTiming.None,
+      operations: [],
+    },
+  },
+  [SemanticType.StreetAddressSupplemental]: {
+    id: SemanticType.StreetAddressSupplemental,
+    displayName: 'Street Address Supplemental',
+    scope: SemanticScope.Property,
+    description: 'Supplemental street address line (e.g., Unit, Suite, Apartment, Floor)',
+    category: SemanticCategory.Contact,
+    applicableDataTypes: ['string'],
+    hasConfig: false,
+    runtime: {
+      timing: SemanticTiming.None,
+      operations: [],
+    },
+  },
+  [SemanticType.City]: {
+    id: SemanticType.City,
+    displayName: 'City',
+    scope: SemanticScope.Property,
+    description: 'City or locality',
+    category: SemanticCategory.Contact,
+    applicableDataTypes: ['string'],
+    hasConfig: false,
+    runtime: {
+      timing: SemanticTiming.None,
+      operations: [],
+    },
+  },
+  [SemanticType.PostalCode]: {
+    id: SemanticType.PostalCode,
+    displayName: 'Postal Code',
+    scope: SemanticScope.Property,
+    description: 'Postal or zip code',
+    category: SemanticCategory.Contact,
+    applicableDataTypes: ['string'],
+    hasConfig: false,
+    runtime: {
+      timing: SemanticTiming.None,
+      operations: [],
+    },
+  },
+  [SemanticType.Country]: {
+    id: SemanticType.Country,
+    displayName: 'Country',
+    scope: SemanticScope.Property,
+    description: 'Country name or code',
+    category: SemanticCategory.Contact,
+    applicableDataTypes: ['string'],
+    hasConfig: true,
+    runtime: {
+      timing: SemanticTiming.None,
+      operations: [],
+    },
+  },
+  [SemanticType.Region]: {
+    id: SemanticType.Region,
+    displayName: 'Region',
+    scope: SemanticScope.Property,
+    description: 'State, province, or region',
+    category: SemanticCategory.Contact,
+    applicableDataTypes: ['string'],
+    hasConfig: false,
+    runtime: {
+      timing: SemanticTiming.None,
+      operations: [],
+    },
+  },
+
   [SemanticType.Version]: {
     id: SemanticType.Version,
     displayName: 'Version Number',

package/src/modeling/definitions/Country.ts

@@ -0,0 +1,62 @@
+import type { AppliedDataSemantic } from '../Semantics.js'
+import { SemanticType } from '../Semantics.js'
+
+export type CountryFormat = 'ISO_3166_Alpha_2' | 'ISO_3166_Alpha_3' | 'Name'
+
+export interface CountryConfig {
+  /**
+   * The format of the country code.
+   *
+   * @default 'Name'
+   */
+  format?: CountryFormat
+
+  /**
+   * The list of allowed countries.
+   */
+  allowedCountries?: string[]
+
+  /**
+   * The list of disallowed countries.
+   */
+  disallowedCountries?: string[]
+  /**
+   * Custom metadata for the country field.
+   */
+  metadata?: Record<string, unknown>
+  /**
+   * Index signature to allow additional properties.
+   */
+  [key: string]: unknown
+}
+
+/**
+ * Type-safe configuration for Country semantic.
+ */
+export interface AppliedCountrySemantic extends AppliedDataSemantic {
+  id: SemanticType.Country
+  config?: CountryConfig
+}
+
+export const isCountrySemantic = (semantic: AppliedDataSemantic): semantic is AppliedCountrySemantic => {
+  return semantic.id === SemanticType.Country
+}
+
+export const createCountrySemantic = (config: CountryConfig = {}): AppliedCountrySemantic => {
+  const mergedConfig = {
+    ...DEFAULT_COUNTRY_CONFIG,
+    ...config,
+  }
+  // Merge metadata separately
+  if (config.metadata) {
+    mergedConfig.metadata = { ...config.metadata }
+  }
+  return {
+    id: SemanticType.Country,
+    config: mergedConfig,
+  }
+}
+
+export const DEFAULT_COUNTRY_CONFIG: CountryConfig = {
+  format: 'ISO_3166_Alpha_2',
+}

package/src/modeling/definitions/PostalCode.ts

@@ -0,0 +1,70 @@
+import type { AppliedDataSemantic } from '../Semantics.js'
+import { SemanticType } from '../Semantics.js'
+/**
+ * Validation Logic Flow:
+ *
+ * When the API receives a POST or PATCH request, the following sequence occurs:
+ * 1. Semantic Trigger: The Runtime identifies a property with the PostalCode semantic and config.validate: true.
+ * 2. Country Lookup: The Runtime identifies the sibling property tagged with `SemanticType.Country`.
+ * 3. Regex Retrieval: The Runtime retrieves the appropriate regex pattern based on the country code.
+ * 4. Validation: The Runtime validates the postal code against the retrieved regex pattern.
+ * 5. Error Handling: If the validation fails, the Runtime returns a 400 Bad Request error with a descriptive message.
+ *   - Example: "Invalid postal code format for country: [CountryCode]."
+ *
+ * Validation libraries:
+ * - https://www.npmjs.com/package/postcode-validator (MIT)
+ * - https://github.com/sashiksu/postal-code-checker (MIT)
+ */
+export interface PostalCodeConfig {
+  /**
+   * Enables regex-based validation based on the value in the sibling property
+   * tagged with `SemanticType.Country`.
+   */
+  validate?: boolean
+
+  /**
+   * The list of allowed postal codes.
+   */
+  allowedPostalCodes?: string[]
+
+  /**
+   * The list of disallowed postal codes.
+   */
+  disallowedPostalCodes?: string[]
+  /**
+   * Custom metadata for the postal code field.
+   */
+  metadata?: Record<string, unknown>
+  /**
+   * Index signature to allow additional properties.
+   */
+  [key: string]: unknown
+}
+
+export interface AppliedPostalCodeSemantic extends AppliedDataSemantic {
+  id: SemanticType.PostalCode
+  config?: PostalCodeConfig
+}
+
+export const DEFAULT_POSTAL_CODE_CONFIG: PostalCodeConfig = {
+  validate: false,
+}
+
+export const isPostalCodeSemantic = (semantic: AppliedDataSemantic): semantic is AppliedPostalCodeSemantic => {
+  return semantic.id === SemanticType.PostalCode
+}
+
+export const createPostalCodeSemantic = (config: PostalCodeConfig = {}): AppliedPostalCodeSemantic => {
+  const mergedConfig = {
+    ...DEFAULT_POSTAL_CODE_CONFIG,
+    ...config,
+  }
+  // Merge metadata separately
+  if (config.metadata) {
+    mergedConfig.metadata = { ...config.metadata }
+  }
+  return {
+    id: SemanticType.PostalCode,
+    config: mergedConfig,
+  }
+}

package/src/modeling/helpers/Intelisense.ts

@@ -12,6 +12,8 @@ import { createDescriptionSemantic } from '../definitions/Description.js'
 import { CURRENCY_PRESETS } from '../definitions/Currency.js'
 import { createStatusSemantic } from '../definitions/Status.js'
 import { SKU_PRESETS } from '../definitions/SKU.js'
+import { createCountrySemantic, DEFAULT_COUNTRY_CONFIG } from '../definitions/Country.js'
+import { createPostalCodeSemantic, DEFAULT_POSTAL_CODE_CONFIG } from '../definitions/PostalCode.js'
 
 /**
  * Adds a field to the given entity that is automatically generated by the system.
@@ -29,6 +31,8 @@ export function addAutoField(entity: DomainEntity, autoField: string): DomainEle
       return addEmailField(entity)
     case 'name':
       return addNameField(entity)
+    case 'display-name':
+      return addDisplayNameField(entity)
     case 'description':
       return addDescriptionField(entity)
     case 'status':
@@ -49,6 +53,8 @@ export function addAutoField(entity: DomainEntity, autoField: string): DomainEle
       return addIsDeletedField(entity)
     case 'deleted':
       return addDeletedAtField(entity)
+    case 'role':
+      return addRoleField(entity)
     case 'first-name':
       return addFirstNameField(entity)
     case 'last-name':
@@ -70,11 +76,25 @@ export function addAutoField(entity: DomainEntity, autoField: string): DomainEle
     case 'images':
       return addImagesField(entity)
     case 'session-id':
+      // This was removed from the UI. We will not support session id configuration
+      // as the platform will handle it to separate the business logic from the transport layer.
       return addSessionIdField(entity)
     case 'expires-at':
+      // This was removed from the UI. We will not support expires at configuration
+      // as the platform will handle it to separate the business logic from the transport layer.
       return addExpiresAtField(entity)
     case 'unit-price':
       return addUnitPriceField(entity)
+    case 'street-address':
+      return addStreetAddressField(entity)
+    case 'city':
+      return addCityField(entity)
+    case 'postal-code':
+      return addPostalCodeField(entity)
+    case 'country':
+      return addCountryField(entity)
+    case 'region':
+      return addRegionField(entity)
     default:
       throw new Error(`Unsupported auto field: ${autoField}`)
   }
@@ -198,6 +218,21 @@ export function addNameField(entity: DomainEntity, info: Partial<IThing> = {}):
   return prop
 }
 
+export function addDisplayNameField(entity: DomainEntity, info: Partial<IThing> = {}): DomainProperty {
+  const existing = findDisplayNameField(entity, true)
+  if (existing) {
+    return existing
+  }
+  const prop = entity.addProperty({
+    info: { name: 'display-name', displayName: 'Display Name', ...info },
+    type: 'string',
+  })
+  prop.addSemantic({
+    id: SemanticType.Name,
+  })
+  return prop
+}
+
 /**
  * Adds a description field to the specified entity.
  * If a description field already exists, it returns the existing field.
@@ -472,6 +507,24 @@ export function addDeletedAtField(entity: DomainEntity, info: Partial<IThing> =
   return prop
 }
 
+export function addRoleField(entity: DomainEntity, info: Partial<IThing> = {}): DomainProperty {
+  const existing = findRoleField(entity, true)
+  if (existing) {
+    return existing
+  }
+  const prop = entity.addProperty({
+    info: { name: 'role', displayName: 'Role', ...info },
+    type: 'string',
+    required: true,
+    index: true,
+    schema: { defaultValue: { type: 'literal', value: 'user' }, enum: ['user', 'admin'] },
+  })
+  prop.addSemantic({
+    id: SemanticType.UserRole,
+  })
+  return prop
+}
+
 /**
  * Adds an is_deleted field to the specified entity.
  * If an is_deleted field already exists, it returns the existing field.
@@ -1134,6 +1187,10 @@ function findNameField(entity: DomainEntity, direct = false): DomainProperty | u
   return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.Title), direct)
 }
 
+function findDisplayNameField(entity: DomainEntity, direct = false): DomainProperty | undefined {
+  return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.Name), direct)
+}
+
 function findDescriptionField(entity: DomainEntity, direct = false): DomainProperty | undefined {
   return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.Description), direct)
 }
@@ -1196,6 +1253,10 @@ function findDeletedAtField(entity: DomainEntity, direct = false): DomainPropert
   )
 }
 
+function findRoleField(entity: DomainEntity, direct = false): DomainProperty | undefined {
+  return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.UserRole), direct)
+}
+
 function findIsDeletedField(entity: DomainEntity, direct = false): DomainProperty | undefined {
   return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.DeletedFlag), direct)
 }
@@ -1313,3 +1374,86 @@ function findExpiresAtField(entity: DomainEntity, direct = false): DomainPropert
     direct
   )
 }
+
+export function addStreetAddressField(entity: DomainEntity, info: Partial<IThing> = {}): DomainProperty {
+  const existing = findStreetAddressField(entity, true)
+  if (existing) return existing
+  const prop = entity.addProperty({
+    info: { name: 'street_address', displayName: 'Street Address', ...info },
+    type: 'string',
+    required: true,
+  })
+  prop.addSemantic({ id: SemanticType.StreetAddress })
+  return prop
+}
+
+function findStreetAddressField(entity: DomainEntity, direct = false): DomainProperty | undefined {
+  return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.StreetAddress), direct)
+}
+
+export function addCityField(entity: DomainEntity, info: Partial<IThing> = {}): DomainProperty {
+  const existing = findCityField(entity, true)
+  if (existing) return existing
+  const prop = entity.addProperty({
+    info: { name: 'city', displayName: 'City', ...info },
+    type: 'string',
+    required: true,
+    index: true,
+  })
+  prop.addSemantic({ id: SemanticType.City })
+  return prop
+}
+
+function findCityField(entity: DomainEntity, direct = false): DomainProperty | undefined {
+  return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.City), direct)
+}
+
+export function addPostalCodeField(entity: DomainEntity, info: Partial<IThing> = {}): DomainProperty {
+  const existing = findPostalCodeField(entity, true)
+  if (existing) return existing
+  const prop = entity.addProperty({
+    info: { name: 'postal_code', displayName: 'Postal Code', ...info },
+    type: 'string',
+    required: true,
+    index: true,
+  })
+  prop.addSemantic(createPostalCodeSemantic(DEFAULT_POSTAL_CODE_CONFIG))
+  return prop
+}
+
+function findPostalCodeField(entity: DomainEntity, direct = false): DomainProperty | undefined {
+  return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.PostalCode), direct)
+}
+
+export function addCountryField(entity: DomainEntity, info: Partial<IThing> = {}): DomainProperty {
+  const existing = findCountryField(entity, true)
+  if (existing) return existing
+  const prop = entity.addProperty({
+    info: { name: 'country', displayName: 'Country', ...info },
+    type: 'string',
+    required: true,
+    index: true,
+  })
+  prop.addSemantic(createCountrySemantic(DEFAULT_COUNTRY_CONFIG))
+  return prop
+}
+
+function findCountryField(entity: DomainEntity, direct = false): DomainProperty | undefined {
+  return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.Country), direct)
+}
+
+export function addRegionField(entity: DomainEntity, info: Partial<IThing> = {}): DomainProperty {
+  const existing = findRegionField(entity, true)
+  if (existing) return existing
+  const prop = entity.addProperty({
+    info: { name: 'region', displayName: 'Region', ...info },
+    type: 'string',
+    index: true,
+  })
+  prop.addSemantic({ id: SemanticType.Region })
+  return prop
+}
+
+function findRegionField(entity: DomainEntity, direct = false): DomainProperty | undefined {
+  return findPropertyField(entity, (property) => property.hasSemantic(SemanticType.Region), direct)
+}

package/src/modeling/templates/verticals/business-services/ecommerce-domain.ts

@@ -25,7 +25,9 @@
 import { DataDomain } from '../../../DataDomain.js'
 import { SemanticType } from '../../../Semantics.js'
 import { createCalculatedSemantic } from '../../../definitions/Calculated.js'
+import { createCountrySemantic, DEFAULT_COUNTRY_CONFIG } from '../../../definitions/Country.js'
 import { createCurrencySemantic } from '../../../definitions/Currency.js'
+import { createPostalCodeSemantic, DEFAULT_POSTAL_CODE_CONFIG } from '../../../definitions/PostalCode.js'
 import { createSummarySemantic } from '../../../definitions/Summary.js'
 import {
   addAvatarUrlField,
@@ -200,6 +202,7 @@ export default function createEcommerceDomain(options: CreateTemplateOptions = {
       displayName: 'Address',
       description: 'Physical address information',
     },
+    semantics: [{ id: SemanticType.Address }],
   })
 
   addIdField(addressEntity, { displayName: 'Address ID', description: 'Unique identifier for the address' })
@@ -221,6 +224,7 @@ export default function createEcommerceDomain(options: CreateTemplateOptions = {
     },
     type: 'string',
     required: true,
+    semantics: [{ id: SemanticType.StreetAddress }],
   })
 
   addressEntity.addProperty({
@@ -231,6 +235,7 @@ export default function createEcommerceDomain(options: CreateTemplateOptions = {
     },
     type: 'string',
     required: false,
+    semantics: [{ id: SemanticType.StreetAddressSupplemental }],
   })
 
   addressEntity.addProperty({
@@ -241,30 +246,35 @@ export default function createEcommerceDomain(options: CreateTemplateOptions = {
     },
     type: 'string',
     required: false,
+    semantics: [{ id: SemanticType.StreetAddressSupplemental }],
   })
 
   addressEntity.addProperty({
     info: { name: 'city', displayName: 'City', description: 'City name' },
     type: 'string',
     required: true,
+    semantics: [{ id: SemanticType.City }],
   })
 
   addressEntity.addProperty({
     info: { name: 'state', displayName: 'State/Province', description: 'State or province' },
     type: 'string',
     required: true,
+    semantics: [{ id: SemanticType.Region }],
   })
 
   addressEntity.addProperty({
     info: { name: 'postal_code', displayName: 'ZIP/Postal Code', description: 'ZIP or postal code' },
     type: 'string',
     required: true,
+    semantics: [createPostalCodeSemantic(DEFAULT_POSTAL_CODE_CONFIG)],
   })
 
   addressEntity.addProperty({
     info: { name: 'country', displayName: 'Country', description: 'Country name' },
     type: 'string',
     required: true,
+    semantics: [createCountrySemantic(DEFAULT_COUNTRY_CONFIG)],
   })
 
   // User-Address Association (One-to-Many)