@keetanetwork/anchor 0.0.14 → 0.0.16

package/services/kyc/utils/generate-kyc-schema.js

@@ -38,6 +38,10 @@ function resolveTypeReference(typeName) {
             return ('Date');
         case 'ENUMERATED':
             return ('string');
+        case 'OBJECT IDENTIFIER':
+            return ('ASN1.ASN1OID');
+        case 'OCTET STRING':
+            return ('Buffer');
         default:
             return (toPascalCase(typeName));
     }
@@ -66,6 +70,11 @@ function resolveToBaseType(typeName) {
     // Otherwise return as-is
     return (typeName);
 }
+function isEnumerationType(typeName) {
+    const normalized = toSnakeCase(typeName);
+    return (Boolean(oidSchema.iso20022_types.enumerations[typeName] ??
+        oidSchema.iso20022_types.enumerations[normalized]));
+}
 function isSequenceOfChoice(config) {
     const hasFields = config.fields && Object.keys(config.fields).length > 0;
     const allOptional = hasFields && Object.values(config.fields).every(function (field) {
@@ -108,7 +117,8 @@ function genInterface(name, fields, description, oid) {
     });
     return (`/** ${description} */\n/** OID: ${oid} */\nexport interface ${name} {\n${fieldLines.join('\n')}\n}\n`);
 }
-function genSequenceOfChoice(name, config) {
+// Generate TypeScript **types** for sequence-of-choice
+function genSequenceOfChoiceTypes(name, config) {
     const typeName = toPascalCase(name);
     const fieldOrder = config.field_order ?? Object.keys(config.fields);
     const choiceEntries = fieldOrder.map(function (fieldName) {
@@ -139,12 +149,51 @@ function genSequenceOfChoice(name, config) {
     }).join('\n\t| ')};\n\n`;
     // Main type is array of choices
     out += `export type ${typeName} = ${typeName}Choice[];\n\n`;
+    return (out);
+}
+// Generate ASN.1 **schema** for sequence-of-choice
+function genSequenceOfChoiceSchema(name, config) {
+    const typeName = toPascalCase(name);
+    const fieldOrder = config.field_order ?? Object.keys(config.fields);
+    const choiceEntries = fieldOrder.map(function (fieldName) {
+        if (!(fieldName in config.fields) || config.fields[fieldName] === undefined) {
+            throw (new Error(`Field ${fieldName} not found in sequence of choice ${name}`));
+        }
+        return ([fieldName, config.fields[fieldName]]);
+    });
+    let out = '';
     // ASN.1 schema
+    out += `/** ASN.1 schema for ${typeName} */\n`;
     out += `export const ${typeName}Schema: ASN1.Schema = {\n\tsequenceOf: {\n\t\tchoice: [\n`;
-    out += choiceEntries.map(function ([_ignore_fieldName, _ignore_fieldConfig], index) {
-        return (`\t\t\t{ type: 'context', kind: 'explicit', value: ${index}, contains: { type: 'string', kind: 'utf8' }}`);
+    out += choiceEntries.map(function ([fieldName, fieldConfig], index) {
+        if (fieldConfig === undefined) {
+            throw (new Error(`Field ${fieldName} not found in sequence of choice ${name}`));
+        }
+        // Determine the type for this choice
+        let fieldType = fieldConfig.type.trim();
+        if (fieldType.startsWith('SEQUENCE OF ')) {
+            fieldType = fieldType.substring('SEQUENCE OF '.length).trim();
+        }
+        fieldType = fieldType.replace(/\[\]$/, '');
+        const fieldTypePascal = toPascalCase(fieldType);
+        const fieldTypeSnake = toSnakeCase(fieldType);
+        // Check if this is a complex type that has a schema
+        const isChoice = oidSchema.iso20022_types.choices[fieldTypeSnake] ?? oidSchema.iso20022_types.choices[fieldType];
+        const isSequence = oidSchema.iso20022_types.sequences[fieldTypeSnake] ?? oidSchema.iso20022_types.sequences[fieldType];
+        const isSensitiveSequence = oidSchema.sensitive_attributes[fieldTypeSnake]?.fields;
+        const isSensitiveChoice = oidSchema.sensitive_attributes[fieldTypeSnake]?.choices;
+        const hasSchema = isChoice ?? isSequence ?? isSensitiveSequence ?? isSensitiveChoice;
+        let contains;
+        if (hasSchema) {
+            contains = `${fieldTypePascal}Schema`;
+        }
+        else {
+            // Primitive type
+            contains = `{ type: 'string', kind: 'utf8' }`;
+        }
+        return (`\t\t\t{ type: 'context', kind: 'explicit', value: ${index}, contains: ${contains} }`);
     }).join(',\n');
-    out += `\n\t\t]\n\t}\n} as const satisfies ASN1.Schema;\n\n`;
+    out += `\n\t\t]\n\t}\n};\n\n`;
     // Field names array
     out += `export const ${typeName}Fields = [\n${fieldOrder.map(function (fieldName) {
         return (`\t'${fieldName}'`);
@@ -187,8 +236,12 @@ function generateOidConstants() {
     lines.push('export namespace keeta {');
     for (const [name, config] of Object.entries(oidSchema.extensions)) {
         lines.push(`\t/** ${config.description} */`);
-        lines.push(`\t/** @see ${config.reference} */`);
-        lines.push(`\texport const ${toConstantCase(name)} = '${oidArrayToString(config.oid)}';`);
+        if (config.reference) {
+            lines.push(`\t/** @see ${config.reference} */`);
+        }
+        if (config.oid) {
+            lines.push(`\texport const ${toConstantCase(name)} = '${oidArrayToString(config.oid)}';`);
+        }
     }
     for (const [name, config] of Object.entries(oidSchema.sensitive_attributes)) {
         lines.push(`\t/** ${config.description} */`);
@@ -223,52 +276,67 @@ function generateOidConstants() {
 }
 function genSequenceSchema(typeName, fields, config) {
     const fieldOrder = config?.field_order ?? Object.keys(fields);
-    const schemaFields = fieldOrder.map(function (fname, index) {
+    const structFields = {};
+    for (const fname of fieldOrder) {
         const fcfg = fields[fname];
         if (!fcfg) {
-            return (null);
+            continue;
         }
         // Resolve to base type to handle aliases
         const baseType = resolveToBaseType(fcfg.type);
+        let fieldSchema;
         // Check if field type is GeneralizedTime (date)
         if (baseType === 'GeneralizedTime') {
-            if (fcfg.optional) {
-                return (`{ optional: { type: 'context', kind: 'explicit', value: ${index}, contains: ASN1.ValidateASN1.IsDate }}`);
+            fieldSchema = 'ASN1.ValidateASN1.IsDate';
+        }
+        else {
+            // Check if this is a SEQUENCE OF type directly or via type reference
+            let fieldType = baseType.trim();
+            const isSequenceOf = fieldType.startsWith('SEQUENCE OF ');
+            if (isSequenceOf) {
+                fieldType = fieldType.substring('SEQUENCE OF '.length).trim();
+            }
+            fieldType = fieldType.replace(/\[\]$/, '');
+            const fieldTypePascal = toPascalCase(fieldType);
+            const fieldTypeSnake = toSnakeCase(fieldType);
+            // Check if this is a COMPLEX type (not a primitive)
+            const isChoice = oidSchema.iso20022_types.choices[fieldTypeSnake] ?? oidSchema.iso20022_types.choices[fieldType];
+            const isSequence = oidSchema.iso20022_types.sequences[fieldTypeSnake] ?? oidSchema.iso20022_types.sequences[fieldType];
+            const isSensitiveSequence = oidSchema.sensitive_attributes[fieldTypeSnake]?.fields;
+            const isSensitiveChoice = oidSchema.sensitive_attributes[fieldTypeSnake]?.choices;
+            const isExtension = oidSchema.extensions[fieldTypeSnake]?.fields ?? oidSchema.extensions[fieldType]?.fields;
+            const hasSchema = isChoice ?? isSequence ?? isSensitiveSequence ?? isSensitiveChoice ?? isExtension;
+            if (hasSchema) {
+                fieldSchema = `${fieldTypePascal}Schema`;
             }
             else {
-                return (`{ type: 'context', kind: 'explicit', value: ${index}, contains: ASN1.ValidateASN1.IsDate }`);
+                // Primitive type - use inline schema
+                if (fieldType === 'OBJECT IDENTIFIER') {
+                    fieldSchema = `ASN1.ValidateASN1.IsOID`;
+                }
+                else if (fieldType === 'OCTET STRING') {
+                    fieldSchema = `ASN1.ValidateASN1.IsOctetString`;
+                }
+                else {
+                    fieldSchema = `{ type: 'string', kind: 'utf8' }`;
+                }
+            }
+            // Wrap in sequenceOf if this was a SEQUENCE OF type
+            if (isSequenceOf) {
+                fieldSchema = `{ sequenceOf: ${fieldSchema} }`;
             }
-        }
-        // Strip SEQUENCE OF prefix and [] suffix to get the base type
-        let fieldType = fcfg.type.trim();
-        if (fieldType.startsWith('SEQUENCE OF ')) {
-            fieldType = fieldType.substring('SEQUENCE OF '.length).trim();
-        }
-        fieldType = fieldType.replace(/\[\]$/, '');
-        const fieldTypePascal = toPascalCase(fieldType);
-        const fieldTypeSnake = toSnakeCase(fieldType);
-        // Check if this is a COMPLEX type (not a primitive)
-        const isChoice = oidSchema.iso20022_types.choices[fieldTypeSnake] ?? oidSchema.iso20022_types.choices[fieldType];
-        const isSequence = oidSchema.iso20022_types.sequences[fieldTypeSnake] ?? oidSchema.iso20022_types.sequences[fieldType];
-        const isSensitiveSequence = oidSchema.sensitive_attributes[fieldTypeSnake]?.fields;
-        const isSensitiveChoice = oidSchema.sensitive_attributes[fieldTypeSnake]?.choices;
-        const hasSchema = isChoice ?? isSequence ?? isSensitiveSequence ?? isSensitiveChoice;
-        let contains;
-        if (hasSchema) {
-            contains = `${fieldTypePascal}Schema `;
-        }
-        else {
-            // Primitive type - use inline string schema
-            contains = `{ type: 'string', kind: 'utf8' }`;
         }
         if (fcfg.optional) {
-            return (`{ optional: { type: 'context', kind: 'explicit', value: ${index}, contains: ${contains}}}`);
+            structFields[fname] = `{ optional: ${fieldSchema} }`;
         }
         else {
-            return (`{ type: 'context', kind: 'explicit', value: ${index}, contains: ${contains}}`);
+            structFields[fname] = fieldSchema;
         }
-    }).filter(Boolean);
-    return (`export const ${typeName}Schema: ASN1.Schema = [\n\t${schemaFields.join(',\n\t')}\n] as const satisfies ASN1.Schema;`);
+    }
+    const containsObject = fieldOrder.map(function (fname) {
+        return (`\t\t${fname}: ${structFields[fname]}`);
+    }).join(',\n');
+    return (`export const ${typeName}Schema: ASN1.Schema = {\n\ttype: 'struct',\n\tfieldNames: [${fieldOrder.map(f => `'${f}'`).join(', ')}],\n\tcontains: {\n${containsObject}\n\t}\n};`);
 }
 function generateIso20022Types() {
     const lines = [genHeader('Generated ISO20022 Type Definitions'), "import * as ASN1 from '../../lib/utils/asn1.js';", ''];
@@ -293,9 +361,9 @@ function generateIso20022Types() {
             return (choiceType !== 'UTF8String' && choiceType !== 'string');
         });
         if (hasComplexTypes) {
-            const unionTypes = choices.map(function ([_ignore_choiceName, choiceConfig]) {
-                return (toPascalCase(choiceConfig.type.trim()));
-            });
+            const unionTypes = Array.from(new Set(choices.map(function ([_ignore_choiceName, choiceConfig]) {
+                return (resolveTypeReference(choiceConfig.type.trim()));
+            })));
             lines.push(genTypeAlias(typeName, unionTypes.join(' | '), config.description, oidArrayToString(config.oid)));
         }
         else {
@@ -306,7 +374,7 @@ function generateIso20022Types() {
     lines.push('// ISO20022 Sequence Types');
     for (const [name, config] of Object.entries(oidSchema.iso20022_types.sequences)) {
         if (isSequenceOfChoice(config)) {
-            lines.push(genSequenceOfChoice(name, config));
+            lines.push(genSequenceOfChoiceTypes(name, config));
         }
         else {
             lines.push(genInterface(toPascalCase(name), config.fields, config.description, oidArrayToString(config.oid)));
@@ -315,15 +383,41 @@ function generateIso20022Types() {
     lines.push('');
     // --- Choice Type Schemas ---
     lines.push('// Generated ASN.1 schemas for ISO 20022 choice types');
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    for (const [name, _ignore_config] of Object.entries(oidSchema.iso20022_types.choices)) {
+    for (const [name, config] of Object.entries(oidSchema.iso20022_types.choices)) {
         const typeName = toPascalCase(name);
+        const choices = Object.entries(config.choices ?? {});
         lines.push(`/** ASN.1 schema for ${typeName} */`);
-        lines.push(`export const ${typeName}Schema: ASN1.Schema = { type: 'string', kind: 'utf8' };`);
+        if (choices.length === 0) {
+            // No choices defined - simple string schema
+            lines.push(`export const ${typeName}Schema: ASN1.Schema = { type: 'string', kind: 'utf8' };`);
+        }
+        else {
+            // Generate choice schema with context tags to make them differentiable
+            const choiceSchemas = choices.map(function ([_ignore_choiceName, choiceConfig], index) {
+                const choiceType = choiceConfig.type.trim();
+                let containsSchema;
+                // Check if it is a primitive type
+                if (choiceType === 'UTF8String' || choiceType === 'Utf8String' || choiceType === 'string' || isEnumerationType(choiceType)) {
+                    containsSchema = `{ type: 'string', kind: 'utf8' }`;
+                }
+                else {
+                    // Complex type - reference its schema
+                    const choiceTypeName = toPascalCase(choiceType);
+                    containsSchema = `${choiceTypeName}Schema`;
+                }
+                // Wrap in context tag to make it differentiable
+                return (`{ type: 'context', kind: 'explicit', value: ${index}, contains: ${containsSchema} }`);
+            });
+            lines.push(`export const ${typeName}Schema: ASN1.Schema = {`);
+            lines.push(`\tchoice: [`);
+            lines.push(`\t\t${choiceSchemas.join(',\n\t\t')}`);
+            lines.push(`\t]`);
+            lines.push(`};`);
+        }
         lines.push('');
     }
-    // --- Sequence Type Schemas ---
-    lines.push('// Generated ASN.1 schemas for ISO 20022 sequence types');
+    // --- Regular Sequence Type Schemas (SECOND - may depend on choice schemas) ---
+    lines.push('// Generated ASN.1 schemas for ISO 20022 regular sequence types');
     for (const [name, config] of Object.entries(oidSchema.iso20022_types.sequences)) {
         const typeName = toPascalCase(name);
         if (config.fields && !isSequenceOfChoice(config)) {
@@ -332,6 +426,13 @@ function generateIso20022Types() {
             lines.push('');
         }
     }
+    // --- Sequence-of-Choice Type Schemas (THIRD - depend on regular sequence schemas) ---
+    lines.push('// Generated ASN.1 schemas for ISO 20022 sequence-of-choice types');
+    for (const [name, config] of Object.entries(oidSchema.iso20022_types.sequences)) {
+        if (isSequenceOfChoice(config)) {
+            lines.push(genSequenceOfChoiceSchema(name, config));
+        }
+    }
     // --- Choice-Type Sensitive Attribute Schemas ---
     lines.push('// Generated ASN.1 schemas for choice-type sensitive attributes');
     for (const [name, config] of Object.entries(oidSchema.sensitive_attributes)) {
@@ -346,7 +447,7 @@ function generateIso20022Types() {
             lines.push(`\tchoice: [`);
             lines.push(`\t\t${choiceSchemas.join(',\n\t\t')}`);
             lines.push(`\t]`);
-            lines.push(`} as const satisfies ASN1.Schema;`);
+            lines.push(`};`);
             lines.push('');
         }
     }
@@ -406,6 +507,27 @@ function generateIso20022Types() {
             lines.push('');
         }
     }
+    // Extension Types with fields
+    for (const [name, config] of Object.entries(oidSchema.extensions)) {
+        if (config.fields) {
+            const typeName = toPascalCase(name);
+            lines.push(`/** ${config.description} */`);
+            if (config.oid) {
+                lines.push(`/** OID: ${oidArrayToString(config.oid)} */`);
+            }
+            lines.push(`export interface ${typeName} {`);
+            for (const [fieldName, fieldConfig] of Object.entries(config.fields)) {
+                const optional = fieldConfig.optional ? '?' : '';
+                const resolvedType = resolveTypeReference(fieldConfig.type);
+                lines.push(`\t${fieldName}${optional}: ${resolvedType};`);
+            }
+            lines.push('}');
+            lines.push('');
+            // Schema
+            lines.push(genSequenceSchema(typeName, config.fields, config));
+            lines.push('');
+        }
+    }
     // Token aliases for sensitive attributes
     lines.push('// Token aliases for sensitive attributes');
     for (const [name, config] of Object.entries(oidSchema.sensitive_attributes)) {
@@ -435,7 +557,45 @@ function generateIso20022Types() {
     lines.push('export type CertificateAttributeValue<Name extends keyof CertificateAttributeValueMap> = CertificateAttributeValueMap[Name];');
     lines.push('');
     // Field arrays and schemas for sequence types
-    for (const [name, config] of Object.entries(oidSchema.sensitive_attributes)) {
+    // Sort to ensure dependencies are defined before they're used
+    const sensitiveAttrEntries = Object.entries(oidSchema.sensitive_attributes);
+    const sortedEntries = [];
+    const processed = new Set();
+    function hasDependency(config, depName) {
+        if (!config.fields) {
+            return (false);
+        }
+        return (Object.values(config.fields).some(field => {
+            const fieldType = field.type.trim();
+            return (fieldType === toPascalCase(depName) || fieldType === depName);
+        }));
+    }
+    // Process entries, dependencies first
+    while (sortedEntries.length < sensitiveAttrEntries.length) {
+        for (const [name, config] of sensitiveAttrEntries) {
+            if (processed.has(name)) {
+                continue;
+            }
+            // Check if all dependencies are processed
+            let allDepsProcessed = true;
+            if (config.fields) {
+                for (const [otherName] of sensitiveAttrEntries) {
+                    if (otherName === name || processed.has(otherName)) {
+                        continue;
+                    }
+                    if (hasDependency(config, otherName)) {
+                        allDepsProcessed = false;
+                        break;
+                    }
+                }
+            }
+            if (allDepsProcessed) {
+                sortedEntries.push([name, config]);
+                processed.add(name);
+            }
+        }
+    }
+    for (const [name, config] of sortedEntries) {
         const typeName = toPascalCase(name);
         if (config.fields) {
             const fieldOrder = config.field_order ?? Object.keys(config.fields);
@@ -498,9 +658,24 @@ function generateIso20022Types() {
                 throw (new Error(`Sensitive attribute ${name} has no defined type.`));
             }
             const baseType = resolveToBaseType(config.type);
-            if (baseType === 'GeneralizedTime') {
+            const baseTypeSnake = toSnakeCase(baseType);
+            const isExtensionType = oidSchema.extensions[baseTypeSnake]?.fields ?? oidSchema.extensions[baseType]?.fields;
+            const isSensitiveType = oidSchema.sensitive_attributes[toSnakeCase(baseType)]?.fields ?? oidSchema.sensitive_attributes[baseType]?.fields;
+            if (isSensitiveType) {
+                schemaRef = `${baseType}Schema`;
+            }
+            else if (isExtensionType) {
+                schemaRef = `${baseType}Schema`;
+            }
+            else if (baseType === 'GeneralizedTime') {
                 schemaRef = 'ASN1.ValidateASN1.IsDate';
             }
+            else if (baseType === 'OCTET STRING') {
+                schemaRef = 'ASN1.ValidateASN1.IsOctetString';
+            }
+            else if (baseType === 'OBJECT IDENTIFIER') {
+                schemaRef = 'ASN1.ValidateASN1.IsOID';
+            }
             else {
                 schemaRef = `{ type: 'string', kind: 'utf8' }`;
             }
@@ -605,7 +780,12 @@ function main(argv) {
         if (undefined === value)
             return true;
         return "object" === typeof value && null !== value && _io22(value);
-    }); const _io22 = input => Array.isArray(input.oid) && input.oid.every(elem => "number" === typeof elem) && (undefined === input.type || "string" === typeof input.type) && "string" === typeof input.description && "string" === typeof input.reference; const _ao0 = (input, _path, _exceptionable = true) => (("object" === typeof input.algorithms && null !== input.algorithms && false === Array.isArray(input.algorithms) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }); const _io22 = input => (undefined === input.oid || Array.isArray(input.oid) && input.oid.every(elem => "number" === typeof elem)) && (undefined === input.type || "string" === typeof input.type) && "string" === typeof input.description && (undefined === input.reference || "string" === typeof input.reference) && (undefined === input.fields || "object" === typeof input.fields && null !== input.fields && false === Array.isArray(input.fields) && _io23(input.fields)) && (undefined === input.field_order || Array.isArray(input.field_order) && input.field_order.every(elem => "string" === typeof elem)); const _io23 = input => Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return "object" === typeof value && null !== value && _io24(value);
+    }); const _io24 = input => "string" === typeof input.type && (undefined === input.optional || "boolean" === typeof input.optional); const _ao0 = (input, _path, _exceptionable = true) => (("object" === typeof input.algorithms && null !== input.algorithms && false === Array.isArray(input.algorithms) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
         path: _path + ".algorithms",
         expected: "__type",
@@ -664,9 +844,9 @@ function main(argv) {
             path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
             expected: "Array<number>",
             value: value
-        }, _errorFactory)) && value.every((elem, _index11) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        }, _errorFactory)) && value.every((elem, _index12) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
             method: "typia.assert",
-            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key) + "[" + _index11 + "]",
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key) + "[" + _index12 + "]",
             expected: "number",
             value: elem
         }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -695,9 +875,9 @@ function main(argv) {
         path: _path + ".oid",
         expected: "Array<number>",
         value: input.oid
-    }, _errorFactory)) && input.oid.every((elem, _index12) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.oid.every((elem, _index13) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
-        path: _path + ".oid[" + _index12 + "]",
+        path: _path + ".oid[" + _index13 + "]",
         expected: "number",
         value: elem
     }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -750,9 +930,9 @@ function main(argv) {
         path: _path + ".field_order",
         expected: "(Array<string> | undefined)",
         value: input.field_order
-    }, _errorFactory)) && input.field_order.every((elem, _index13) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.field_order.every((elem, _index14) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
-        path: _path + ".field_order[" + _index13 + "]",
+        path: _path + ".field_order[" + _index14 + "]",
         expected: "string",
         value: elem
     }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -865,9 +1045,9 @@ function main(argv) {
         path: _path + ".oid",
         expected: "Array<number>",
         value: input.oid
-    }, _errorFactory)) && input.oid.every((elem, _index14) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.oid.every((elem, _index15) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
-        path: _path + ".oid[" + _index14 + "]",
+        path: _path + ".oid[" + _index15 + "]",
         expected: "number",
         value: elem
     }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -905,9 +1085,9 @@ function main(argv) {
         path: _path + ".oid",
         expected: "Array<number>",
         value: input.oid
-    }, _errorFactory)) && input.oid.every((elem, _index15) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.oid.every((elem, _index16) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
-        path: _path + ".oid[" + _index15 + "]",
+        path: _path + ".oid[" + _index16 + "]",
         expected: "number",
         value: elem
     }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -920,9 +1100,9 @@ function main(argv) {
         path: _path + ".values",
         expected: "Array<string>",
         value: input.values
-    }, _errorFactory)) && input.values.every((elem, _index16) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.values.every((elem, _index17) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
-        path: _path + ".values[" + _index16 + "]",
+        path: _path + ".values[" + _index17 + "]",
         expected: "string",
         value: elem
     }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -955,9 +1135,9 @@ function main(argv) {
         path: _path + ".oid",
         expected: "Array<number>",
         value: input.oid
-    }, _errorFactory)) && input.oid.every((elem, _index17) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.oid.every((elem, _index18) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
-        path: _path + ".oid[" + _index17 + "]",
+        path: _path + ".oid[" + _index18 + "]",
         expected: "number",
         value: elem
     }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -1020,9 +1200,9 @@ function main(argv) {
         path: _path + ".oid",
         expected: "Array<number>",
         value: input.oid
-    }, _errorFactory)) && input.oid.every((elem, _index18) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.oid.every((elem, _index19) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
-        path: _path + ".oid[" + _index18 + "]",
+        path: _path + ".oid[" + _index19 + "]",
         expected: "number",
         value: elem
     }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -1045,9 +1225,9 @@ function main(argv) {
         path: _path + ".field_order",
         expected: "(Array<string> | undefined)",
         value: input.field_order
-    }, _errorFactory)) && input.field_order.every((elem, _index19) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.field_order.every((elem, _index20) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
-        path: _path + ".field_order[" + _index19 + "]",
+        path: _path + ".field_order[" + _index20 + "]",
         expected: "string",
         value: elem
     }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
@@ -1100,20 +1280,20 @@ function main(argv) {
             expected: "__type.o20",
             value: value
         }, _errorFactory);
-    }); const _ao22 = (input, _path, _exceptionable = true) => ((Array.isArray(input.oid) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }); const _ao22 = (input, _path, _exceptionable = true) => (undefined === input.oid || (Array.isArray(input.oid) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
         path: _path + ".oid",
-        expected: "Array<number>",
+        expected: "(Array<number> | undefined)",
         value: input.oid
-    }, _errorFactory)) && input.oid.every((elem, _index20) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && input.oid.every((elem, _index21) => "number" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
-        path: _path + ".oid[" + _index20 + "]",
+        path: _path + ".oid[" + _index21 + "]",
         expected: "number",
         value: elem
     }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
         path: _path + ".oid",
-        expected: "Array<number>",
+        expected: "(Array<number> | undefined)",
         value: input.oid
     }, _errorFactory)) && (undefined === input.type || "string" === typeof input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
@@ -1125,11 +1305,61 @@ function main(argv) {
         path: _path + ".description",
         expected: "string",
         value: input.description
-    }, _errorFactory)) && ("string" === typeof input.reference || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+    }, _errorFactory)) && (undefined === input.reference || "string" === typeof input.reference || __typia_transform__assertGuard._assertGuard(_exceptionable, {
         method: "typia.assert",
         path: _path + ".reference",
-        expected: "string",
+        expected: "(string | undefined)",
         value: input.reference
+    }, _errorFactory)) && (undefined === input.fields || ("object" === typeof input.fields && null !== input.fields && false === Array.isArray(input.fields) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assert",
+        path: _path + ".fields",
+        expected: "(__type.o21 | undefined)",
+        value: input.fields
+    }, _errorFactory)) && _ao23(input.fields, _path + ".fields", true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assert",
+        path: _path + ".fields",
+        expected: "(__type.o21 | undefined)",
+        value: input.fields
+    }, _errorFactory)) && (undefined === input.field_order || (Array.isArray(input.field_order) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assert",
+        path: _path + ".field_order",
+        expected: "(Array<string> | undefined)",
+        value: input.field_order
+    }, _errorFactory)) && input.field_order.every((elem, _index22) => "string" === typeof elem || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assert",
+        path: _path + ".field_order[" + _index22 + "]",
+        expected: "string",
+        value: elem
+    }, _errorFactory)) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assert",
+        path: _path + ".field_order",
+        expected: "(Array<string> | undefined)",
+        value: input.field_order
+    }, _errorFactory)); const _ao23 = (input, _path, _exceptionable = true) => false === _exceptionable || Object.keys(input).every(key => {
+        const value = input[key];
+        if (undefined === value)
+            return true;
+        return ("object" === typeof value && null !== value || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "__type.o22",
+            value: value
+        }, _errorFactory)) && _ao24(value, _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key), true && _exceptionable) || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+            method: "typia.assert",
+            path: _path + __typia_transform__accessExpressionAsString._accessExpressionAsString(key),
+            expected: "__type.o22",
+            value: value
+        }, _errorFactory);
+    }); const _ao24 = (input, _path, _exceptionable = true) => ("string" === typeof input.type || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assert",
+        path: _path + ".type",
+        expected: "string",
+        value: input.type
+    }, _errorFactory)) && (undefined === input.optional || "boolean" === typeof input.optional || __typia_transform__assertGuard._assertGuard(_exceptionable, {
+        method: "typia.assert",
+        path: _path + ".optional",
+        expected: "(boolean | undefined)",
+        value: input.optional
     }, _errorFactory)); const __is = input => "object" === typeof input && null !== input && _io0(input); let _errorFactory; return (input, errorFactory) => {
         if (false === __is(input)) {
             _errorFactory = errorFactory;