feat: ensure all JSON Structure types are covered in samples and validators

- Updated schema and instance validators to support all primitive types:
  - Added int8, uint8, int16, uint16, int128, uint128, float8 validation
  - Added integer type (alias for int32 per spec PR #16)
  - Moved 'any' from primitive to compound types

- Updated 03-financial-types sample to demonstrate all types:
  - Added number, integer, double, null, int16, int32 type usage
  - Updated examples with new fields (weight, discountPercent,
    paymentTermsDays, cancelledDate, sequenceNumber)

All 34 JSON Structure types are now covered across the samples.

Author: Clemens Vasters

samples/core/03-financial-types/example1.json

@@ -3,30 +3,35 @@
   "invoiceNumber": "INV-2023-001",
   "issueDate": "2023-11-13",
   "dueDate": "2023-12-13",
+  "paymentTermsDays": 30,
   "lineItems": [
     {
       "description": "Professional Services",
-      "quantity": "10.000",
+      "quantity": 10,
       "unitPrice": {
         "amount": "150.00",
         "currency": "USD"
       },
       "totalPrice": {
         "amount": "1500.00",
         "currency": "USD"
-      }
+      },
+      "weight": 0.0,
+      "discountPercent": 0
     },
     {
       "description": "Software License",
-      "quantity": "1.000",
+      "quantity": 1,
       "unitPrice": {
         "amount": "299.99",
         "currency": "USD"
       },
       "totalPrice": {
         "amount": "299.99",
         "currency": "USD"
-      }
+      },
+      "weight": 0.5,
+      "discountPercent": 10.5
     }
   ],
   "subtotal": {
@@ -41,5 +46,6 @@
   "totalAmount": {
     "amount": "1957.49",
     "currency": "USD"
-  }
+  },
+  "cancelledDate": null
 }

samples/core/03-financial-types/example2.json

@@ -3,18 +3,21 @@
   "invoiceNumber": "INV-2023-002",
   "issueDate": "2023-11-14",
   "dueDate": "2023-11-28",
+  "paymentTermsDays": 14,
   "lineItems": [
     {
       "description": "Monthly Subscription",
-      "quantity": "1.000",
+      "quantity": 1,
       "unitPrice": {
         "amount": "49.99",
         "currency": "EUR"
       },
       "totalPrice": {
         "amount": "49.99",
         "currency": "EUR"
-      }
+      },
+      "weight": 0.0,
+      "discountPercent": 0
     }
   ],
   "subtotal": {
@@ -24,5 +27,6 @@
   "totalAmount": {
     "amount": "49.99",
     "currency": "EUR"
-  }
+  },
+  "cancelledDate": "2023-11-20"
 }

samples/core/03-financial-types/example3.json

@@ -3,43 +3,49 @@
   "invoiceNumber": "INV-2023-003",
   "issueDate": "2023-11-15",
   "dueDate": "2023-12-15",
+  "paymentTermsDays": 30,
   "lineItems": [
     {
       "description": "Consulting Hours",
-      "quantity": "25.500",
+      "quantity": 26,
       "unitPrice": {
         "amount": "200.00",
         "currency": "GBP"
       },
       "totalPrice": {
-        "amount": "5100.00",
+        "amount": "5200.00",
         "currency": "GBP"
-      }
+      },
+      "weight": 0.0,
+      "discountPercent": 5
     },
     {
       "description": "Travel Expenses",
-      "quantity": "1.000",
+      "quantity": 1,
       "unitPrice": {
         "amount": "450.75",
         "currency": "GBP"
       },
       "totalPrice": {
         "amount": "450.75",
         "currency": "GBP"
-      }
+      },
+      "weight": 15.5,
+      "discountPercent": 0
     }
   ],
   "subtotal": {
-    "amount": "5550.75",
+    "amount": "5650.75",
     "currency": "GBP"
   },
   "taxRate": "0.2000",
   "taxAmount": {
-    "amount": "1110.15",
+    "amount": "1130.15",
     "currency": "GBP"
   },
   "totalAmount": {
-    "amount": "6660.90",
+    "amount": "6780.90",
     "currency": "GBP"
-  }
+  },
+  "cancelledDate": null
 }

samples/core/03-financial-types/schema.struct.json

@@ -34,10 +34,8 @@
           "maxLength": 200
         },
         "quantity": {
-          "type": "decimal",
-          "description": "Quantity of items",
-          "precision": 10,
-          "scale": 3
+          "type": "integer",
+          "description": "Quantity of items (whole number)"
         },
         "unitPrice": {
           "type": { "$ref": "#/definitions/Money" },
@@ -46,6 +44,14 @@
         "totalPrice": {
           "type": { "$ref": "#/definitions/Money" },
           "description": "Total price for this line item"
+        },
+        "weight": {
+          "type": "double",
+          "description": "Weight of the item in kilograms (double precision)"
+        },
+        "discountPercent": {
+          "type": "number",
+          "description": "Discount percentage as a raw JSON number"
         }
       },
       "required": ["description", "quantity", "unitPrice", "totalPrice"]
@@ -60,8 +66,12 @@
           "maxLength": 50
         },
         "sequenceNumber": {
+          "type": "int32",
+          "description": "Sequential invoice number for internal tracking"
+        },
+        "globalSequenceNumber": {
           "type": "int64",
-          "description": "Sequential invoice number for audit trail"
+          "description": "Global sequential invoice number for audit trail"
         },
         "issueDate": {
           "type": "date",
@@ -73,8 +83,7 @@
         },
         "paymentTermsDays": {
           "type": "int16",
-          "description": "Number of days for payment terms",
-          "default": 30
+          "description": "Number of days for payment terms (1-365 typical range)"
         },
         "lineItems": {
           "type": "array",
@@ -106,6 +115,10 @@
         "blockchainHash": {
           "type": "uint128", 
           "description": "Unsigned 128-bit blockchain transaction hash for immutable record"
+        },
+        "cancelledDate": {
+          "type": ["date", "null"],
+          "description": "Date the invoice was cancelled, or null if not cancelled"
         }
       },
       "required": ["invoiceNumber", "issueDate", "dueDate", "lineItems", "subtotal", "totalAmount"]

samples/py/json_structure_instance_validator.py

@@ -258,11 +258,31 @@ def validate_instance(self, instance, schema=None, path="#", meta=None):
         elif schema_type == "null":
             if instance is not None:
                 self.errors.append(f"Expected null at {path}, got {type(instance).__name__}")
-        elif schema_type == "int32":
+        elif schema_type == "int8":
             if not isinstance(instance, int):
-                self.errors.append(f"Expected int32 at {path}, got {type(instance).__name__}")
+                self.errors.append(f"Expected int8 at {path}, got {type(instance).__name__}")
+            elif not (-2**7 <= instance <= 2**7 - 1):
+                self.errors.append(f"int8 value at {path} out of range")
+        elif schema_type == "uint8":
+            if not isinstance(instance, int):
+                self.errors.append(f"Expected uint8 at {path}, got {type(instance).__name__}")
+            elif not (0 <= instance <= 2**8 - 1):
+                self.errors.append(f"uint8 value at {path} out of range")
+        elif schema_type == "int16":
+            if not isinstance(instance, int):
+                self.errors.append(f"Expected int16 at {path}, got {type(instance).__name__}")
+            elif not (-2**15 <= instance <= 2**15 - 1):
+                self.errors.append(f"int16 value at {path} out of range")
+        elif schema_type == "uint16":
+            if not isinstance(instance, int):
+                self.errors.append(f"Expected uint16 at {path}, got {type(instance).__name__}")
+            elif not (0 <= instance <= 2**16 - 1):
+                self.errors.append(f"uint16 value at {path} out of range")
+        elif schema_type == "int32" or schema_type == "integer":
+            if not isinstance(instance, int):
+                self.errors.append(f"Expected {schema_type} at {path}, got {type(instance).__name__}")
             elif not (-2**31 <= instance <= 2**31 - 1):
-                self.errors.append(f"int32 value at {path} out of range")
+                self.errors.append(f"{schema_type} value at {path} out of range")
         elif schema_type == "uint32":
             if not isinstance(instance, int):
                 self.errors.append(f"Expected uint32 at {path}, got {type(instance).__name__}")
@@ -288,6 +308,29 @@ def validate_instance(self, instance, schema=None, path="#", meta=None):
                         self.errors.append(f"uint64 value at {path} out of range")
                 except ValueError:
                     self.errors.append(f"Invalid uint64 format at {path}")
+        elif schema_type == "int128":
+            if not isinstance(instance, str):
+                self.errors.append(f"Expected int128 as string at {path}, got {type(instance).__name__}")
+            else:
+                try:
+                    value = int(instance)
+                    if not (-2**127 <= value <= 2**127 - 1):
+                        self.errors.append(f"int128 value at {path} out of range")
+                except ValueError:
+                    self.errors.append(f"Invalid int128 format at {path}")
+        elif schema_type == "uint128":
+            if not isinstance(instance, str):
+                self.errors.append(f"Expected uint128 as string at {path}, got {type(instance).__name__}")
+            else:
+                try:
+                    value = int(instance)
+                    if not (0 <= value <= 2**128 - 1):
+                        self.errors.append(f"uint128 value at {path} out of range")
+                except ValueError:
+                    self.errors.append(f"Invalid uint128 format at {path}")
+        elif schema_type == "float8":
+            if not isinstance(instance, (int, float)):
+                self.errors.append(f"Expected float8 at {path}, got {type(instance).__name__}")
         elif schema_type in ("float", "double"):
             if not isinstance(instance, (int, float)):
                 self.errors.append(f"Expected {schema_type} at {path}, got {type(instance).__name__}")
@@ -548,7 +591,9 @@ def validate(self, instance, schema=None):
                     import re
                     if not re.match(schema["pattern"], instance):
                         errors.append(f"String does not match pattern {schema['pattern']}")
-            if t == "number" or t == "int32" or t == "float" or t == "double":
+            if t in ("number", "integer", "float", "double", "float8", "decimal",
+                     "int8", "uint8", "int16", "uint16", "int32", "uint32", 
+                     "int64", "uint64", "int128", "uint128"):
                 if "minimum" in schema and instance < schema["minimum"]:
                     errors.append(f"Number less than minimum {schema['minimum']}")
                 if "maximum" in schema and instance > schema["maximum"]:
@@ -675,7 +720,9 @@ def _validate_validation_addins(self, schema, instance, path):
         [Metaschema: JSON Structure JSONStructureValidation]
         """
         # Numeric constraints.
-        if schema.get("type") in ("number", "integer", "float", "double", "decimal", "int32", "uint32", "int64", "uint64", "int128", "uint128"):
+        if schema.get("type") in ("number", "integer", "float", "double", "decimal", 
+                                   "int8", "uint8", "int16", "uint16", "int32", "uint32", 
+                                   "int64", "uint64", "int128", "uint128", "float8"):
             if "minimum" in schema:
                 try:
                     if instance < schema["minimum"]:

samples/py/json_structure_schema_validator.py

@@ -42,12 +42,12 @@ class JSONStructureSchemaCoreValidator:
         "values", "choices", "selector", "tuple"
     }
     PRIMITIVE_TYPES = {
-        "string", "number", "boolean", "null", "int8", "uint8", "int16", "uint16",
+        "string", "number", "integer", "boolean", "null", "int8", "uint8", "int16", "uint16",
         "int32", "uint32", "int64", "uint64", "int128", "uint128", "float8", 
         "float", "double", "decimal", "date", "datetime", "time", "duration", 
-        "uuid", "uri", "binary", "jsonpointer", "any"
+        "uuid", "uri", "binary", "jsonpointer"
     }
-    COMPOUND_TYPES = {"object", "array", "set", "map", "tuple", "choice"}
+    COMPOUND_TYPES = {"object", "array", "set", "map", "tuple", "choice", "any"}
 
     # Extended keywords for conditional composition
     COMPOSITION_KEYWORDS = {"allOf", "anyOf", "oneOf", "not", "if", "then", "else"}