Model System

class CodegenModel implements IJsonSchemaValidationProperties {
    // Basic model information
    public String name;               // Schema name as in OpenAPI
    public String schemaName;         // Original schema name
    public String classname;          // Language-specific class name
    public String title;
    public String description;
    public String classVarName;
    public String modelJson;
    public String dataType;
    public String classFilename;
    
    // Inheritance
    public String parent;             // Parent class name
    public String parentSchema;       // Parent schema reference
    public List<String> interfaces;   // Implemented interfaces
    public List<String> allParents;   // All parent classes in hierarchy
    public CodegenModel parentModel;  // Resolved parent model
    public List<CodegenModel> interfaceModels; // Resolved interface models
    public List<CodegenModel> children; // Child models
    
    // Composition schemas (oneOf/anyOf/allOf)
    public Set<String> anyOf;
    public Set<String> oneOf;
    public Set<String> allOf;
    
    // Properties
    public List<CodegenProperty> vars;           // All properties
    public List<CodegenProperty> requiredVars;   // Required properties only
    public List<CodegenProperty> optionalVars;   // Optional properties only
    public List<CodegenProperty> readOnlyVars;   // Read-only properties
    public List<CodegenProperty> readWriteVars;  // Read-write properties
    public Map<String, CodegenProperty> requiredVarsMap; // Required properties map
    
    // Discriminator support
    public CodegenDiscriminator discriminator;
    
    // Behavioral flags
    public boolean hasVars;           // Has any properties
    public boolean hasRequired;       // Has required properties
    public boolean hasOptional;       // Has optional properties
    public boolean hasEnums;          // Contains enum properties
    public boolean isEnum;            // Is an enum model
    public boolean isArrayModel;      // Represents array type
    public boolean isMapModel;        // Represents map/dictionary type
}

class CodegenProperty implements Cloneable, IJsonSchemaValidationProperties {
    // Basic property information
    public String baseName;           // Original property name from OpenAPI
    public String complexType;        // Full type including generics
    public String getter;            // Getter method name
    public String setter;            // Setter method name
    public String description;
    public String title;
    public String unescapedDescription;
    
    // Type information
    public String dataType;          // Language-specific data type
    public String datatypeWithEnum;  // Data type with enum suffix
    public String dataFormat;        // OpenAPI format (date, email, etc.)
    public String name;              // Language-specific property name
    public String jsonSchema;
    
    // Validation constraints
    public String minimum;
    public String maximum;
    public boolean exclusiveMinimum;
    public boolean exclusiveMaximum;
    public Integer minLength;
    public Integer maxLength;
    public Integer minItems;
    public Integer maxItems;
    public String pattern;
    public Number multipleOf;
    
    // Behavioral flags
    public boolean isReadOnly;
    public boolean isWriteOnly;
    public boolean isRequired;
    public boolean isNullable;
    public boolean isOptional;
    public boolean hasMore;          // For template iteration
    public boolean isInherited;      // Inherited from parent
    public boolean isDiscriminator;  // Is discriminator property
    
    // Type flags
    public boolean isString;
    public boolean isNumeric;
    public boolean isInteger;
    public boolean isLong;
    public boolean isNumber;
    public boolean isFloat;
    public boolean isDouble;
    public boolean isDecimal;
    public boolean isBoolean;
    public boolean isDate;
    public boolean isDateTime;
    public boolean isEnum;
    public boolean isContainer;
    public boolean isListContainer;
    public boolean isMapContainer;
    public boolean isPrimitiveType;
    public boolean isModel;
    
    // Container properties
    public CodegenProperty items;             // For arrays
    public CodegenProperty additionalProperties; // For maps
    public List<CodegenProperty> vars;        // For nested objects
    
    // Default and example values
    public String defaultValue;
    public Object example;
    public List<Object> examples;
    
    // Enum values
    public List<Object> allowableValues;
    public Map<String, Object> allowableValuesMap;
}

class CodegenOperation {
    // Basic operation information
    public String path;              // URL path with parameters
    public String operationId;       // Unique operation identifier
    public String httpMethod;        // HTTP method (GET, POST, etc.)
    public String nickname;          // Generated method name
    public String summary;           // Operation summary
    public String notes;             // Detailed description
    public String baseName;          // Base name for method generation
    
    // Parameters
    public List<CodegenParameter> allParams;      // All parameters
    public List<CodegenParameter> bodyParams;     // Request body parameters
    public List<CodegenParameter> pathParams;     // Path parameters
    public List<CodegenParameter> queryParams;    // Query parameters
    public List<CodegenParameter> headerParams;   // Header parameters
    public List<CodegenParameter> formParams;     // Form parameters
    public List<CodegenParameter> cookieParams;   // Cookie parameters
    public List<CodegenParameter> requiredParams; // Required parameters
    public List<CodegenParameter> optionalParams; // Optional parameters
    
    // Response information
    public List<CodegenResponse> responses;       // All responses
    public CodegenResponse defaultResponse;       // Default response
    public boolean returnTypeIsPrimitive;
    public String returnType;                     // Return type name
    public String returnContainer;                // Container type (list, map)
    
    // Behavioral flags
    public boolean hasParams;
    public boolean hasQueryParams;
    public boolean hasPathParams;
    public boolean hasBodyParam;
    public boolean hasFormParams;
    public boolean hasConsumes;          // Has request content types
    public boolean hasProduces;          // Has response content types
    public boolean isResponseOptional;
    public boolean hasAuthMethods;       // Requires authentication
    
    // Content types
    public List<Map<String, String>> consumes;   // Request content types
    public List<Map<String, String>> produces;   // Response content types
    
    // Authentication and security
    public List<CodegenSecurity> authMethods;
    public boolean hasMore;              // For template iteration
    
    // Vendor extensions
    public Map<String, Object> vendorExtensions;
}

class CodegenParameter implements IJsonSchemaValidationProperties {
    // Basic parameter information
    public String baseName;          // Original parameter name
    public String paramName;         // Language-specific parameter name
    public String description;
    public String unescapedDescription;
    
    // Type and format information
    public String dataType;          // Language-specific data type
    public String dataFormat;        // OpenAPI format
    public String collectionFormat;  // Array parameter format
    
    // Location flags
    public boolean isPathParam;
    public boolean isQueryParam;
    public boolean isHeaderParam;
    public boolean isBodyParam;
    public boolean isFormParam;
    public boolean isCookieParam;
    
    // Type flags
    public boolean isFile;
    public boolean isContainer;
    public boolean isString;
    public boolean isNumeric;
    public boolean isInteger;
    public boolean isLong;
    public boolean isPrimitiveType;
    public boolean isModel;
    public boolean isExplode;        // OpenAPI 3.0 explode parameter
    
    // Constraints and validation
    public boolean isRequired;
    public boolean isNullable;
    public String defaultValue;
    public Object example;
    public String jsonSchema;
    
    // Validation constraints (inherited from IJsonSchemaValidationProperties)
    public String minimum;
    public String maximum;
    public boolean exclusiveMinimum;
    public boolean exclusiveMaximum;
    public Integer minLength;
    public Integer maxLength;
    public Integer minItems;
    public Integer maxItems;
    public String pattern;
    
    // Container properties
    public CodegenProperty items;    // For array parameters
    
    // Template iteration
    public boolean hasMore;
    
    // Vendor extensions
    public Map<String, Object> vendorExtensions;
}

class CodegenResponse implements IJsonSchemaValidationProperties {
    // Response identification
    public String code;              // HTTP status code (e.g., "200", "4XX")
    public String message;           // Response description
    public String schema;            // Response schema reference
    
    // Type information
    public String dataType;          // Language-specific data type
    public String baseType;          // Base type without containers
    public String containerType;     // Container type (array/map)
    public boolean returnTypeIsPrimitive;
    
    // Type flags
    public boolean isString;
    public boolean isNumeric;
    public boolean isInteger;
    public boolean isLong;
    public boolean isNumber;
    public boolean isBoolean;
    public boolean isBinary;
    public boolean isByteArray;
    public boolean isDate;
    public boolean isDateTime;
    public boolean isUuid;
    public boolean isModel;
    public boolean isContainer;
    
    // Response details
    public List<CodegenProperty> headers;  // Response headers
    public Object example;
    public List<Object> examples;
    public String jsonSchema;
    
    // Behavioral flags
    public boolean hasHeaders;
    public boolean isDefault;        // Default response (no status code)
    public boolean isWildcard;       // Wildcard status code (e.g., 2XX)
    public boolean hasMore;          // For template iteration
    
    // Content types
    public List<Map<String, String>> produces;
    
    // Vendor extensions
    public Map<String, Object> vendorExtensions;
}

class ModelsMap extends HashMap<String, Object> {
    public void setModels(List<ModelMap> modelMaps);
    public List<ModelMap> getModels();
    public void setImports(List<Map<String, String>> imports);
    public List<Map<String, String>> getImports();
    public List<Map<String, String>> getImportsOrEmpty();
}

class OperationsMap extends HashMap<String, Object> {
    public void setOperation(OperationMap objs);
    public OperationMap getOperations();
    public void setImports(List<Map<String, String>> imports);
    public List<Map<String, String>> getImports();
}

class ModelMap extends HashMap<String, Object> {
    // Typically contains:
    // "model" -> CodegenModel
    // "classname" -> String
    // "description" -> String
    // Additional template variables
}

class OperationMap extends HashMap<String, Object> {
    // Typically contains:
    // "operation" -> List<CodegenOperation>
    // "classname" -> String
    // "package" -> String
    // Additional template variables
}

public class CustomGenerator extends DefaultCodegen {
    
    @Override
    public CodegenModel fromModel(String name, Schema schema) {
        CodegenModel model = super.fromModel(name, schema);
        
        // Customize model properties
        model.classname = "Custom" + model.classname;
        
        // Process model properties
        for (CodegenProperty property : model.vars) {
            if (property.isString && property.maxLength != null) {
                property.vendorExtensions.put("x-max-length", property.maxLength);
            }
        }
        
        return model;
    }
    
    @Override
    public Map<String, ModelsMap> postProcessAllModels(Map<String, ModelsMap> objs) {
        Map<String, ModelsMap> result = super.postProcessAllModels(objs);
        
        // Add custom processing for all models
        for (ModelsMap models : result.values()) {
            for (ModelMap modelMap : models.getModels()) {
                CodegenModel model = (CodegenModel) modelMap.get("model");
                
                // Add validation annotations for required properties
                for (CodegenProperty prop : model.requiredVars) {
                    prop.vendorExtensions.put("x-validation-required", true);
                }
            }
        }
        
        return result;
    }
}

@Override
public CodegenOperation fromOperation(String resourcePath, String httpMethod, 
                                      Operation operation, List<Server> servers) {
    CodegenOperation op = super.fromOperation(resourcePath, httpMethod, operation, servers);
    
    // Customize operation
    op.nickname = "custom" + StringUtils.camelize(op.nickname);
    
    // Process parameters
    for (CodegenParameter param : op.allParams) {
        if (param.isQueryParam && param.isRequired) {
            param.vendorExtensions.put("x-required-query", true);
        }
    }
    
    // Process responses
    for (CodegenResponse response : op.responses) {
        if ("200".equals(response.code)) {
            response.vendorExtensions.put("x-success-response", true);
        }
    }
    
    return op;
}

@Override
public OperationsMap postProcessOperationsWithModels(OperationsMap objs, List<ModelMap> allModels) {
    OperationsMap result = super.postProcessOperationsWithModels(objs, allModels);
    
    // Access operations
    OperationMap operations = result.getOperations();
    List<CodegenOperation> ops = (List<CodegenOperation>) operations.get("operation");
    
    // Add custom template variables
    operations.put("hasAsyncOperations", 
        ops.stream().anyMatch(op -> op.vendorExtensions.containsKey("x-async")));
    
    // Group operations by tag
    Map<String, List<CodegenOperation>> operationsByTag = ops.stream()
        .collect(Collectors.groupingBy(op -> 
            op.tags != null && !op.tags.isEmpty() ? op.tags.get(0).getName() : "default"));
    
    operations.put("operationsByTag", operationsByTag);
    
    return result;
}