# datamodel-code-generator CLI Options Consultation

## Your Question

What other options should I use?

## Current CLI Options

```
--input schema.json
--output-model-type pydantic_v2.BaseModel
--snake-case-field
```

## Options by Category

### Base Options
- `--emit-model-metadata`: Write a separate JSON map from source schema references to the final generated models...
- `--encoding`: Specify character encoding for input and output files.
- `--external-ref-mapping`: Map external `$ref` files to Python packages.
- `--input`: Specify the input schema file path.
- `--input-file-type`: Specify the input file type for code generation.
- `--input-model`: Import a Python type or dict schema from a module or Python file.
- `--input-model-ref-strategy`: Strategy for referenced types when using --input-model.
- `--output`: Specify the destination path for generated Python code.
- `--preset`: Apply an immutable built-in option preset.
- `--schema-version`: Schema version to use for parsing.
- `--schema-version-mode`: Schema version validation mode.
- `--url`: Fetch schema from URL with custom HTTP headers.

### Typing Customization
- `--allof-class-hierarchy`: Controls how allOf schemas are represented in the generated class hierarchy.
- `--allof-merge-mode`: Merge constraints from root model references in allOf schemas.
- `--disable-future-imports`: Prevent automatic addition of __future__ imports in generated code.
- `--enum-field-as-literal`: Convert all enum fields to Literal types instead of Enum classes.
- `--enum-field-as-literal-map`: Override enum/literal generation per-field via JSON mapping.
- `--ignore-enum-constraints`: Ignore enum constraints and use base string type instead of Enum classes.
- `--no-use-annotated`
- `--no-use-closed-typed-dict`: Disable PEP 728 TypedDict closed/extra_items generation.
- `--no-use-specialized-enum`: Disable specialized Enum classes for Python 3.11+ code generation.
- `--no-use-standard-collections`: Use typing.Dict/List instead of built-in dict/list for container types.
- `--no-use-standard-primitive-types`
- `--no-use-union-operator`: Use Union[X, Y] / Optional[X] instead of X | Y union operator.
- `--output-date-class`: Specify date class type for date schema fields.
- `--output-datetime-class`: Specify datetime class type for date-time schema fields.
- `--strict-types`: Enable strict type validation for specified Python types.
- `--type-mappings`: Override default type mappings for schema formats.
- `--type-overrides`: Replace schema model types with custom Python types via JSON mapping.
- `--use-annotated`: Use typing.Annotated for Field() with constraints.
- `--use-closed-typed-dict`: Generate TypedDict with PEP 728 closed/extra_items (default: enabled).
- `--use-decimal-for-multiple-of`: Generate Decimal types for fields with multipleOf constraint.
- `--use-generic-container-types`: Use generic container types (Sequence, Mapping) for type hinting.
- `--use-non-positive-negative-number-constrained-types`: Use NonPositive/NonNegative types for number constraints.
- `--use-object-type`: Use object instead of Any for unspecified object and array values.
- `--use-pendulum`: Use pendulum types for date, time, and duration fields.
- `--use-root-model-type-alias`: Generate RootModel as type alias format for better mypy support.
- `--use-specialized-enum`: Generate StrEnum/IntEnum for string/integer enums (Python 3.11+).
- `--use-standard-collections`: Use built-in dict/list instead of typing.Dict/List.
- `--use-standard-primitive-types`: Use Python standard library types for string formats instead of str.
- `--use-tuple-for-fixed-items`: Generate tuple types for arrays with items array syntax.
- `--use-type-alias`: Use TypeAlias instead of root models for type definitions (experimental).
- `--use-union-operator`: Use | operator for Union types (PEP 604).
- `--use-unique-items-as-set`: Generate set types for arrays with uniqueItems constraint.

### Field Customization
- `--aliases`: Apply custom field and class name aliases via inline JSON or a JSON file path.
- `--capitalize-enum-members`: Capitalize enum member names to UPPER_CASE format.
- `--default-values`: Override field default values via inline JSON or a JSON file path.
- `--empty-enum-field-name`: Name for empty string enum field values.
- `--extra-fields`: Configure how generated models handle extra fields not defined in schema.
- `--field-constraints`: Generate Field() with validation constraints from schema.
- `--field-extra-keys`: Include specific extra keys in Field() definitions.
- `--field-extra-keys-without-x-prefix`: Include schema extension keys in Field() without requiring 'x-' prefix.
- `--field-include-all-keys`: Include all schema keys in Field() json_schema_extra.
- `--field-type-collision-strategy`: Rename type class instead of field when names collide (Pydantic v2 only).
- `--infer-union-variant-names`: Infer names for inline oneOf/anyOf object variants from literal fields.
- `--no-alias`: Disable Field alias generation for non-Python-safe property names.
- `--no-snake-case-field`
- `--original-field-name-delimiter`: Specify delimiter for original field names when using snake-case conversion.
- `--remove-special-field-name-prefix`: Remove the special prefix from field names.
- `--serialization-aliases`: Apply custom Pydantic v2 serialization aliases via inline JSON or a JSON file path.
- `--set-default-enum-member`: Set the first enum member as the default value for enum fields.
- `--snake-case-field`: Convert field names to snake_case format.
- `--special-field-name-prefix`: Prefix to add to special field names (like reserved keywords).
- `--use-attribute-docstrings`: Generate field descriptions as attribute docstrings instead of Field descriptions.
- `--use-enum-values-in-discriminator`: Use enum values in discriminator mappings for union types.
- `--use-field-description`: Include schema descriptions as Field docstrings.
- `--use-field-description-example`: Add field examples to docstrings.
- `--use-inline-field-description`: Add field descriptions as inline comments.
- `--use-schema-description`: Use schema description as class docstring.
- `--use-serialization-alias`: Use serialization_alias instead of alias for field aliasing (Pydantic v2 only).
- `--use-single-line-docstring`: Emit short docstrings on a single line.
- `--use-title-as-name`: Use schema title as the generated class name.

### Model Customization
- `--alias-generator`: Use a Pydantic v2 alias generator in model_config.
- `--allow-extra-fields`: Allow extra fields in generated Pydantic models (extra='allow').
- `--allow-leading-underscore-class-name`: Allow an explicitly specified root class name to start with an unders...
- `--allow-population-by-field-name`: Allow Pydantic model population by field name (not just alias).
- `--base-class`: Specify a custom base class for generated models.
- `--base-class-map`: Specify different base classes for specific models via JSON mapping.
- `--class-name`: Override the auto-generated class name with a custom name.
- `--class-name-affix-scope`: Control which classes receive the prefix/suffix.
- `--class-name-prefix`: Add a prefix to all generated class names.
- `--class-name-suffix`: Add a suffix to all generated class names.
- `--collapse-reuse-models`: Collapse duplicate models by replacing references instead of inheritance.
- `--collapse-root-models`: Inline root model definitions instead of creating separate wrapper classes.
- `--collapse-root-models-name-strategy`: Select which name to keep when collapsing root models with object refe...
- `--dataclass-arguments`: Customize dataclass decorator arguments via JSON dictionary.
- `--duplicate-name-suffix`: Customize suffix for duplicate model names.
- `--enable-faux-immutability`: Enable faux immutability in Pydantic models (frozen=True).
- `--force-optional`: Force all fields to be Optional regardless of required status.
- `--frozen-dataclasses`: Generate frozen dataclasses with optional keyword-only fields.
- `--keep-model-order`: Keep generated model order deterministic while respecting dependency constraints.
- `--keyword-only`: Generate dataclasses with keyword-only fields (Python 3.10+).
- `--model-extra-keys`: Add model-level schema extensions to ConfigDict json_schema_extra.
- `--model-extra-keys-without-x-prefix`: Strip x- prefix from model-level schema extensions and add to ConfigDic...
- `--model-name-map`: Rename generated model classes from a JSON mapping.
- `--naming-strategy`: Use parent-prefixed naming strategy for duplicate model names.
- `--no-allow-population-by-field-name`
- `--no-collapse-root-models`
- `--no-use-frozen-field`
- `--output-model-type`: Generate models from GraphQL with different output model types.
- `--parent-scoped-naming`: Namespace models by their parent scope to avoid naming conflicts.
- `--reuse-model`: Reuse identical model definitions instead of generating duplicates.
- `--reuse-scope`: Scope for model reuse detection (root or tree).
- `--skip-root-model`: Skip generation of root model when schema contains nested definitions.
- `--strict-nullable`: Treat default field as a non-nullable field.
- `--strip-default-none`: Remove fields with None as default value from generated models.
- `--target-pydantic-version`: Target Pydantic version for generated code compatibility.
- `--target-python-version`: Target Python version for generated code syntax and imports.
- `--union-mode`: Union mode for combining anyOf/oneOf schemas (smart or left_to_right).
- `--use-default`: Use default values from schema in generated models.
- `--use-default-factory-for-optional-nested-models`: Generate default_factory for optional nested model fields.
- `--use-default-kwarg`: Use default= keyword argument instead of positional argument for fields with defaults.
- `--use-frozen-field`: Generate frozen (immutable) field definitions for readOnly properties.
- `--use-generic-base-class`: Generate a shared base class with model configuration to avoid repetition (DRY).
- `--use-missing-sentinel`: Use Pydantic's MISSING sentinel for optional fields without defaults.
- `--use-one-literal-as-default`: Use single literal value as default when enum has only one option.
- `--use-root-model-sequence-interface`: Make non-null sequence-like Pydantic v2 RootModel classes implement col...
- `--use-serialize-as-any`: Wrap fields with subtypes in Pydantic's SerializeAsAny.
- `--use-subclass-enum`: Generate typed Enum subclasses for enums with specific field types.

### Template Customization
- `--additional-imports`: Add custom imports to generated output files.
- `--class-decorators`: Add custom decorators to generated model classes.
- `--custom-file-header`: Add custom header text to the generated file.
- `--custom-file-header-path`: Add custom header content from file to generated code.
- `--custom-formatters`: Apply custom Python code formatters to generated output.
- `--custom-formatters-kwargs`: Pass custom arguments to custom formatters via inline JSON or a JSON file path.
- `--custom-template-dir`: Use custom Jinja2 templates for model generation.
- `--disable-appending-item-suffix`: Disable appending 'Item' suffix to array item types.
- `--disable-timestamp`: Disable timestamp in generated file header for reproducible output.
- `--enable-command-header`: Include command-line options in file header for reproducibility.
- `--enable-generated-header-marker`: Include the @generated marker in file header for generated-code tooling.
- `--enable-version-header`: Include tool version information in file header.
- `--extra-template-data`: Pass custom template variables via inline JSON or a JSON file path.
- `--formatters`: Specify code formatters to apply to generated output.
- `--generate-schema-validators`: Generate experimental Pydantic v2 model validators for JSON Schema runtime rules.
- `--no-treat-dot-as-module`: Keep dots in schema names as underscores for flat output.
- `--no-use-type-checking-imports`: Keep generated model imports available at runtime when using Ruff fixes.
- `--schema-validator-base-class-name`: Set the generated shared Pydantic v2 schema runtime validator base class...
- `--schema-validator-type`: Select the schema-derived runtime validator backend.
- `--use-double-quotes`: Use double quotes for string literals in generated code.
- `--use-exact-imports`: Import exact types instead of modules.
- `--use-type-checking-imports`: Allow Ruff to move typing-only imports into TYPE_CHECKING blocks.
- `--validators`: Add custom field validators to generated Pydantic v2 models.
- `--wrap-string-literal`: Wrap long string literals across multiple lines.

### OpenAPI-only Options
- `--include-path-parameters`: Include OpenAPI path parameters in generated parameter models.
- `--openapi-include-info-version`: Emit OpenAPI info.version as a generated constant.
- `--openapi-include-paths`: Filter OpenAPI paths to include in model generation.
- `--openapi-scopes`: Specify OpenAPI scopes to generate (schemas, paths, parameters).
- `--read-only-write-only-model-type`: Generate separate request and response models for readOnly/writeOnly fields.
- `--use-operation-id-as-name`: Use OpenAPI operationId as the generated function/class name.
- `--use-status-code-in-response-name`: Include HTTP status code in response model names.
- `--validation`: Enable validation constraints (deprecated, use --field-constraints).

### GraphQL-only Options
- `--graphql-no-typename`: Exclude __typename field from generated GraphQL models.

### General Options
- `--all-exports-collision-strategy`: Handle name collisions when exporting recursive module hierarchies.
- `--all-exports-scope`: Generate __all__ exports for child modules in __init__.py files.
- `--allow-private-network`: Allow HTTP requests to private network schema endpoints.
- `--allow-remote-refs`: Enable fetching of `$ref` targets over HTTP/HTTPS.
- `--check`: Verify generated code matches existing output without modifying files.
- `--disable-warnings`: Suppress warning messages during code generation.
- `--generate-cli-command`: Generate CLI command from pyproject.toml configuration.
- `--generate-pyproject-config`: Generate pyproject.toml configuration from CLI arguments.
- `--http-headers`: Fetch schema from URL with custom HTTP headers.
- `--http-ignore-tls`: Disable TLS certificate verification for HTTPS requests.
- `--http-local-ref-path`: Resolve HTTP references from local schema files.
- `--http-query-parameters`: Add query parameters to HTTP requests for remote schemas.
- `--http-timeout`: Set timeout for HTTP requests to remote hosts.
- `--ignore-pyproject`: Ignore pyproject.toml configuration file.
- `--module-split-mode`: Split generated models into separate files, one per model class.
- `--no-allow-private-network`
- `--no-allow-remote-refs`
- `--shared-module-name`: Customize the name of the shared module for deduplicated models.
- `--watch`: Watch input file(s) for changes and regenerate output automatically.
- `--watch-delay`: Set debounce delay in seconds for watch mode.

## All Available Options (Full Help)

```
usage: 
  datamodel-codegen [options]

Generate Python data models from schema definitions or structured data

For detailed usage, see: https://datamodel-code-generator.koxudaxi.dev

[36;1mOptions[0m:
  --additional-imports ADDITIONAL_IMPORTS
                        Custom imports for output (delimited list input). For
                        example "datetime.date,datetime.datetime"
  --allow-private-network, --no-allow-private-network
                        Allow HTTP(S) schema requests to private, loopback,
                        link-local, or otherwise non-public network hosts. By
                        default these targets are blocked to reduce server-
                        side request forgery (SSRF) risk. If a trusted
                        internal schema endpoint is blocked, verify the URL
                        and pass this option; otherwise use a local schema
                        file or public endpoint. Pass --no-allow-private-
                        network to override a configuration file that enables
                        it.
  --allow-remote-refs, --no-allow-remote-refs
                        Allow fetching remote $ref references over HTTP/HTTPS.
                        Currently remote fetching is allowed by default but
                        emits a deprecation warning. Pass --allow-remote-refs
                        to opt in without warning, or --no-allow-remote-refs
                        to block remote fetching. In a future version, remote
                        fetching will be disabled by default.
  --class-decorators CLASS_DECORATORS
                        Custom decorators for generated model classes
                        (delimited list input). For example
                        "@dataclass_json(letter_case=LetterCase.CAMEL)". The
                        "@" prefix is optional and will be added automatically
                        if missing.
  --custom-formatters CUSTOM_FORMATTERS
                        List of modules with custom formatter (delimited list
                        input).
  --emit-model-metadata EMIT_MODEL_METADATA
                        Write a separate JSON map from source schema
                        references to generated models and fields.
  --external-ref-mapping FILE_PATH=PYTHON_PACKAGE [FILE_PATH=PYTHON_PACKAGE ...]
                        Map external $ref file paths to Python import packages
                        instead of generating duplicate classes. Accepts one
                        or more mappings after a single flag. Format:
                        "path/to/schema.yaml=mypackage.models". When a $ref
                        points to a mapped file, an import statement is
                        generated instead of a class definition.
  --formatters {builtin,black,isort,ruff-check,ruff-format} [{builtin,black,isort,ruff-check,ruff-format} ...]
                        Formatters for output (default: [black, isort]; use
                        builtin for dependency-free formatting)
  --http-headers HTTP_HEADER [HTTP_HEADER ...]
                        Set headers in HTTP requests to the remote host.
                        (example: "Authorization: Basic dXNlcjpwYXNz")
  --http-ignore-tls     Disable verification of the remote host's TLS
                        certificate
  --http-local-ref-path HTTP_LOCAL_REF_PATH
                        Resolve HTTP(S) JSON Schema $ref URLs from a local
                        directory instead of fetching them. URLs are mapped
                        under the directory by host and path; extensionless
                        refs also try '.json'.
  --http-query-parameters HTTP_QUERY_PARAMETERS [HTTP_QUERY_PARAMETERS ...]
                        Set query parameters in HTTP requests to the remote
                        host. (example: "ref=branch")
  --http-timeout HTTP_TIMEOUT
                        Timeout in seconds for HTTP requests to remote hosts
                        (default: 30)
  --input INPUT         Input file/directory (default: stdin)
  --input-file-type {auto,openapi,asyncapi,jsonschema,mcp-tools,xmlschema,protobuf,avro,json,yaml,dict,csv,graphql}
                        Input file type (default: auto). Use 'jsonschema',
                        'openapi', 'asyncapi', 'graphql', 'mcp-tools',
                        'xmlschema', 'protobuf', or 'avro' for schema
                        definitions. Use 'json', 'yaml', or 'csv' for raw
                        sample data to infer a schema automatically.
  --input-model MODULE_OR_PATH:NAME
                        Python import path or file path to a Pydantic v2 model
                        or schema dict (e.g., 'mypackage.module:ClassName',
                        './models.py:ClassName', or
                        'mypackage.schemas:SCHEMA_DICT'). Can be specified
                        multiple times for related models with inheritance.
                        For dict input, --input-file-type is required. Cannot
                        be used with --input or --url.
  --input-model-ref-strategy {regenerate-all,reuse-foreign,reuse-all}
                        Strategy for referenced types in --input-model.
                        'regenerate-all': Regenerate all types. 'reuse-
                        foreign': Reuse types from different families (Enum,
                        etc.), regenerate same-family. 'reuse-all': Reuse all
                        referenced types via import. If not specified,
                        defaults to regenerate-all behavior.
  --output OUTPUT       Output file (default: stdout)
  --output-model-type {pydantic_v2.BaseModel,pydantic_v2.dataclass,dataclasses.dataclass,typing.TypedDict,msgspec.Struct}
                        Output model type (default: pydantic_v2.BaseModel)
  --preset {standard-py310-20260619,standard-py311-20260619,standard-py312-20260619,standard-py313-20260619,standard-py314-20260619,practical-py310-20260619,practical-py311-20260619,practical-py312-20260619,practical-py313-20260619,practical-py314-20260619}
                        Apply an immutable built-in option preset. Preset
                        names include the target Python version so generated
                        syntax is pinned.
  --schema-version SCHEMA_VERSION
                        Schema version. Valid values depend on input type:
                        JsonSchema: auto, draft-04, draft-06, draft-07,
                        2019-09, 2020-12. OpenAPI: auto, 3.0, 3.1, 3.2.
                        AsyncAPI: auto, 2.0, 3.0. XMLSchema: auto, 1.0, 1.1.
                        Protobuf: auto, proto2, proto3, 2023. (default: auto -
                        detected from $schema, openapi/asyncapi field, XML
                        Schema versioning attributes, or Protobuf
                        syntax/edition)
  --schema-version-mode {lenient,strict}
                        Schema version validation mode. 'lenient': accept all
                        features regardless of version (default). 'strict':
                        warn on features outside declared/detected version.
  --url URL             Input file URL. `--input` is ignored when `--url` is
                        used

[36;1mTyping customization[0m:
  --allof-class-hierarchy {if-no-conflict,always}
                        How to map allOf references to class hierarchies. 'if-
                        no-conflict': only create subclasses when parent class
                        has no conflicting property definition. 'always':
                        always create subclasses.
  --allof-merge-mode {constraints,all,none}
                        Mode for field merging in allOf schemas.
                        'constraints': merge only constraints (minItems,
                        maxItems, pattern, etc.) from parent (default). 'all':
                        merge constraints plus annotations (default, examples)
                        from parent. 'none': do not merge any fields from
                        parent properties.
  --base-class BASE_CLASS
                        Base Class (default: pydantic.BaseModel)
  --base-class-map BASE_CLASS_MAP
                        Model-specific base class mapping (JSON or JSON file
                        path). Example: '{"MyModel": "custom.BaseA",
                        "OtherModel": "custom.BaseB"}'. Priority: base-class-
                        map > customBasePath (in schema) > base-class.
  --disable-future-imports
                        Disable __future__ imports
  --enum-field-as-literal {all,one,none}
                        Parse enum field as literal. all: all enum field type
                        are Literal. one: field type is Literal when an enum
                        has only one possible value. none: always use Enum
                        class (never convert to Literal)
  --enum-field-as-literal-map ENUM_FIELD_AS_LITERAL_MAP
                        Per-field override for enum/literal generation (JSON
                        or JSON file path). Format: JSON object mapping field
                        names to 'literal' or 'enum'. Example: '{"status":
                        "literal", "priority": "enum"}'. Overrides --enum-
                        field-as-literal for matched fields.
  --field-constraints   Use field constraints and not con* annotations
  --ignore-enum-constraints
                        Ignore enum constraints and use the base type (e.g.,
                        str, int) instead of generating Enum classes
  --set-default-enum-member
                        Set enum members as default values for enum field
  --strict-types {str,bytes,int,float,bool} [{str,bytes,int,float,bool} ...]
                        Use strict types
  --type-mappings TYPE_MAPPINGS [TYPE_MAPPINGS ...]
                        Override default type mappings. Format:
                        "type+format=target" (e.g., "string+binary=string" to
                        map binary format to string type) or "format=target"
                        (e.g., "binary=string"). Can be specified multiple
                        times.
  --type-overrides TYPE_OVERRIDES
                        Replace schema model types with custom Python types.
                        Format: JSON object mapping model names to Python
                        import paths. Model-level: '{"CustomType":
                        "my_app.types.MyType"}' replaces all references.
                        Scoped: '{"User.field": "my_app.Type"}' replaces
                        specific field only.
  --use-annotated, --no-use-annotated
                        Use typing.Annotated for Field(). Also, `--field-
                        constraints` option will be enabled. Will become
                        default for Pydantic v2 in a future version.
  --use-closed-typed-dict, --no-use-closed-typed-dict
                        Generate TypedDict with PEP 728
                        closed=True/extra_items for additionalProperties
                        constraints. Use --no-use-closed-typed-dict for type
                        checkers that don't yet support PEP 728 (e.g., mypy).
  --use-decimal-for-multiple-of
                        Use condecimal instead of confloat for float/number
                        fields with multipleOf constraint (Pydantic only).
                        Avoids floating-point precision issues in validation.
  --use-enum-values-in-discriminator
                        Use enum member literals in discriminator fields
                        instead of string literals
  --use-generic-container-types
                        Use generic container types for type hinting
                        (typing.Sequence, typing.Mapping). If `--use-standard-
                        collections` option is set, then import from
                        collections.abc instead of typing
  --use-non-positive-negative-number-constrained-types
                        Use the Non{Positive,Negative}{FloatInt} types instead
                        of the corresponding con* constrained types.
  --use-object-type     Use object instead of Any for unspecified JSON Schema
                        object and array values
  --use-one-literal-as-default
                        Use one literal as default value for one literal field
  --use-root-model-type-alias
                        Use type alias format for RootModel (e.g., Foo =
                        RootModel[Bar]) instead of class inheritance (Pydantic
                        v2 only)
  --use-serialize-as-any
                        Use pydantic.SerializeAsAny for fields with types that
                        have subtypes (Pydantic v2 only)
  --use-specialized-enum, --no-use-specialized-enum
                        Use specialized Enum class (StrEnum, IntEnum).
                        Requires --target-python-version 3.11+
  --use-standard-collections, --no-use-standard-collections
                        Use standard collections for type hinting (list,
                        dict). Default: enabled
  --use-subclass-enum   Define generic Enum class as subclass with field type
                        when enum has type (int, float, bytes, str)
  --use-tuple-for-fixed-items
                        Generate tuple types for arrays with items array
                        syntax when minItems equals maxItems equals items
                        length
  --use-type-alias      Use TypeAlias instead of root models (experimental)
  --use-union-operator, --no-use-union-operator
                        Use | operator for Union type (PEP 604). Default:
                        enabled
  --use-unique-items-as-set
                        define field type as `set` when the field attribute
                        has `uniqueItems`

[36;1mField customization[0m:
  --capitalise-enum-members, --capitalize-enum-members
                        Capitalize field names on enum
  --empty-enum-field-name EMPTY_ENUM_FIELD_NAME
                        Set field name when enum value is empty (default: `_`)
  --field-extra-keys FIELD_EXTRA_KEYS [FIELD_EXTRA_KEYS ...]
                        Add extra keys to field parameters
  --field-extra-keys-without-x-prefix FIELD_EXTRA_KEYS_WITHOUT_X_PREFIX [FIELD_EXTRA_KEYS_WITHOUT_X_PREFIX ...]
                        Add extra keys with `x-` prefix to field parameters.
                        The extra keys are stripped of the `x-` prefix.
  --field-include-all-keys
                        Add all keys to field parameters
  --field-type-collision-strategy {rename-field,rename-type}
                        Strategy for handling field name and type name
                        collisions (Pydantic v2 only). 'rename-field': rename
                        field with suffix and add alias (default). 'rename-
                        type': rename type class with suffix to preserve field
                        name.
  --force-optional      Force optional for required fields
  --model-extra-keys MODEL_EXTRA_KEYS [MODEL_EXTRA_KEYS ...]
                        Add extra keys from schema extensions (x-* fields) to
                        model_config json_schema_extra
  --model-extra-keys-without-x-prefix MODEL_EXTRA_KEYS_WITHOUT_X_PREFIX [MODEL_EXTRA_KEYS_WITHOUT_X_PREFIX ...]
                        Add extra keys with `x-` prefix to model_config
                        json_schema_extra. The extra keys are stripped of the
                        `x-` prefix.
  --no-alias            Do not add a field alias. E.g., if --snake-case-field
                        is used along with a base class, which has an
                        alias_generator
  --original-field-name-delimiter ORIGINAL_FIELD_NAME_DELIMITER
                        Set delimiter to convert to snake case. This option
                        only can be used with --snake-case-field (default: `_`
                        )
  --remove-special-field-name-prefix
                        Remove field name prefix if it has a special meaning
                        e.g. underscores
  --serialization-aliases SERIALIZATION_ALIASES
                        Serialization alias mapping as inline JSON or a JSON
                        file path for Pydantic v2. Format: {'<schema_field>':
                        '<serialization_alias>'}. Supports hierarchical
                        formats: Flat: {'name': 'fullName'} applies to all
                        occurrences. Scoped: {'User.name': 'fullName'} applies
                        to specific class.
  --snake-case-field, --no-snake-case-field
                        Change camel-case field name to snake-case
  --special-field-name-prefix SPECIAL_FIELD_NAME_PREFIX
                        Set field name prefix when first character can't be
                        used as Python field name (default: `field`)
  --strict-nullable     Treat default field as a non-nullable field
  --strip-default-none  Strip default None on fields
  --union-mode {smart,left_to_right}
                        Union mode for only pydantic v2 field
  --use-attribute-docstrings
                        Set use_attribute_docstrings=True in Pydantic v2
                        ConfigDict
  --use-default         Use default value even if a field is required
  --use-default-factory-for-optional-nested-models
                        Use default_factory for optional nested model fields
                        instead of None default. E.g., `field: Model | None =
                        Field(default_factory=Model)` instead of `field: Model
                        | None = None`
  --use-default-kwarg   Use `default=` instead of a positional argument for
                        Fields that have default values.
  --use-field-description
                        Use schema description to populate field docstring
  --use-field-description-example
                        Use schema example to populate field docstring
  --use-frozen-field, --no-use-frozen-field
                        Use Field(frozen=True) for readOnly fields (Pydantic
                        v2).
  --use-inline-field-description
                        Use schema description to populate field docstring as
                        inline docstring
  --use-missing-sentinel
                        Use pydantic.experimental.missing_sentinel.MISSING for
                        optional fields without defaults (Pydantic v2.12+).
  --use-serialization-alias
                        Use serialization_alias instead of alias for field
                        aliasing (Pydantic v2 only). This allows setting
                        values using the Pythonic field name while serializing
                        to the original name.
  --use-single-line-docstring
                        Use single-line docstrings when the content fits on
                        one line

[36;1mModel customization[0m:
  --alias-generator {to_camel,to_pascal,to_snake}
                        Pydantic v2 BaseModel alias generator to use in
                        ConfigDict. Matching generated aliases are omitted
                        from individual Field() calls.
  --all-exports-collision-strategy {error,minimal-prefix,full-prefix}
                        Strategy for name collisions when using --all-exports-
                        scope=recursive. 'error': raise an error (default).
                        'minimal-prefix': add module prefix only to colliding
                        names. 'full-prefix': add full module path prefix to
                        colliding names.
  --all-exports-scope {children,recursive}
                        Generate __all__ in __init__.py with re-exports.
                        'children': export from direct child modules only.
                        'recursive': export from all descendant modules.
  --allow-extra-fields  Deprecated: --allow-extra-fields is deprecated. Use
                        --extra-fields=allow instead.
  --allow-leading-underscore-class-name
                        Allow an explicitly specified root class name to start
                        with an underscore
  --allow-population-by-field-name, --no-allow-population-by-field-name
                        Allow population by field name
  --class-name CLASS_NAME
                        Set class name of root model
  --class-name-affix-scope {all,models,enums}
                        Scope for applying --class-name-prefix/--class-name-
                        suffix. 'all': Apply to all classes including enums
                        (default). 'models': Apply only to model classes.
                        'enums': Apply only to enum classes.
  --class-name-prefix CLASS_NAME_PREFIX
                        Prefix to add to generated class names (e.g., 'Api'
                        produces 'ApiUser'). Does not apply to root model when
                        --class-name is specified.
  --class-name-suffix CLASS_NAME_SUFFIX
                        Suffix to add to generated class names (e.g., 'Schema'
                        produces 'UserSchema'). Does not apply to root model
                        when --class-name is specified.
  --collapse-reuse-models
                        When used with --reuse-model, collapse duplicate
                        models by replacing references instead of creating
                        empty inheritance subclasses. This eliminates 'class
                        Foo(Bar): pass' patterns
  --collapse-root-models, --no-collapse-root-models
                        Models generated with a root-type field will be merged
                        into the models using that root-type model
  --collapse-root-models-name-strategy {child,parent}
                        Strategy for naming when collapsing root models that
                        reference other models. 'child': Keep inner model's
                        name (default). 'parent': Use wrapper's name for inner
                        model. Requires --collapse-root-models to be set.
  --dataclass-arguments DATACLASS_ARGUMENTS
                        Custom dataclass arguments as a JSON dictionary, e.g.
                        '{"frozen": true, "kw_only": true}'. Overrides
                        --frozen-dataclasses and similar flags.
  --disable-appending-item-suffix
                        Disable appending `Item` suffix to model name in an
                        array
  --disable-timestamp   Disable timestamp on file headers
  --duplicate-name-suffix DUPLICATE_NAME_SUFFIX
                        JSON mapping of type to suffix for resolving duplicate
                        name conflicts. Example: '{"model": "Schema"}' changes
                        Address1 to AddressSchema. Keys: 'model' (for
                        classes), 'enum' (for enums), 'default' (fallback).
                        When not specified, uses numeric suffix (Address1,
                        Address2).
  --enable-command-header
                        Enable command-line options on file headers for
                        reproducibility
  --enable-faux-immutability
                        Enable faux immutability
  --enable-generated-header-marker
                        Enable @generated marker on file headers
  --enable-version-header
                        Enable package version on file headers
  --extra-fields {allow,ignore,forbid}
                        Set the generated models to allow, forbid, or ignore
                        extra fields.
  --frozen-dataclasses  Generate frozen dataclasses (dataclass(frozen=True)).
                        Only applies to dataclass output.
  --infer-union-variant-names
                        Infer inline oneOf/anyOf branch model names from
                        literal discriminator-style fields
  --keep-model-order    Keep generated models' order
  --keyword-only        Defined models as keyword only (for example
                        dataclass(kw_only=True)).
  --model-name-map MODEL_NAME_MAP
                        Rename generated model classes by schema ref or
                        current generated class name using a JSON object or
                        JSON file.
  --module-split-mode {single}
                        Split generated models into separate files. 'single':
                        generate one file per model class.
  --naming-strategy {numbered,parent-prefixed,full-path,primary-first}
                        Strategy for generating unique model names when
                        duplicates occur. 'numbered' (default): Append numeric
                        suffix (Address, Address1, Address2). Simple but names
                        don't indicate context. 'parent-prefixed': Prefix with
                        parent model name using underscore (Company_Address,
                        Company_Employee_Address for nested). Names show
                        hierarchy. 'full-path': Similar to parent-prefixed but
                        joins with CamelCase (CompanyAddress,
                        CompanyEmployeeAddress). More readable for deep
                        nesting. 'primary-first': Keep clean names for primary
                        definitions (in /definitions/ or
                        /components/schemas/), only add suffix to
                        inline/nested duplicates.
  --output-date-class {date,PastDate,FutureDate}
                        Choose Date class between PastDate, FutureDate or
                        date. (Pydantic v2 only) Each output model has its
                        default mapping.
  --output-datetime-class {datetime,AwareDatetime,NaiveDatetime,PastDatetime,FutureDatetime}
                        Choose Datetime class between AwareDatetime,
                        NaiveDatetime, PastDatetime, FutureDatetime or
                        datetime. Each output model has its default mapping
                        (for example pydantic: datetime, dataclass: str, ...)
  --parent-scoped-naming
                        Deprecated: --parent-scoped-naming is deprecated. Use
                        --naming-strategy parent-prefixed instead.
  --reuse-model         Reuse models on the field when a module has the model
                        with the same content
  --reuse-scope {module,tree}
                        Scope for model reuse deduplication: module (per-file,
                        default) or tree (cross-file with shared module). Only
                        effective when --reuse-model is set.
  --shared-module-name SHARED_MODULE_NAME
                        Name of the shared module for --reuse-scope=tree
                        (default: "shared"). Use this option if your schema
                        has a file named "shared".
  --skip-root-model     Skip generating the model for the root schema element
  --target-pydantic-version {2,2.11,2.12}
                        Target Pydantic version for generated code. '2':
                        Pydantic 2.0+ compatible (default, uses
                        populate_by_name). '2.11': Pydantic 2.11+ (uses
                        validate_by_name). '2.12': Pydantic 2.12+ (supports
                        MISSING sentinel).
  --target-python-version {3.10,3.11,3.12,3.13,3.14}
                        target python version
  --treat-dot-as-module, --no-treat-dot-as-module
                        Treat dotted schema names as module paths, creating
                        nested directory structures (e.g., 'foo.bar.Model'
                        becomes 'foo/bar.py'). Use --no-treat-dot-as-module to
                        keep dots in names as underscores for single-file
                        output.
  --use-exact-imports   import exact types instead of modules, for example:
                        "from .foo import Bar" instead of "from . import foo"
                        with "foo.Bar"
  --use-generic-base-class
                        Generate a shared base class with model configuration
                        (e.g., extra='forbid') instead of repeating the
                        configuration in each model. Keeps code DRY.
  --use-pendulum        use pendulum instead of datetime
  --use-root-model-sequence-interface
                        Make non-null sequence-like Pydantic v2 RootModel
                        classes implement collections.abc.Sequence by adding
                        Sequence[T] inheritance and root-delegating __iter__,
                        __getitem__, and __len__ methods
  --use-schema-description
                        Use schema description to populate class docstring
  --use-standard-primitive-types, --no-use-standard-primitive-types
                        Use Python standard library types for string formats
                        (UUID, IPv4Address, etc.) instead of str. Affects
                        dataclass, msgspec, TypedDict output. Pydantic already
                        uses these types by default.
  --use-title-as-name   use titles as class names of models

[36;1mTemplate customization[0m:
  --aliases ALIASES     Alias mapping as inline JSON or a JSON file path for
                        renaming fields. Format: {'<schema_field>':
                        '<python_name>'} - the schema field name becomes the
                        Pydantic alias. Supports hierarchical formats: Flat:
                        {'id': 'id_'} applies to all occurrences. Scoped:
                        {'User.name': 'user_name'} applies to specific class.
                        Priority: scoped > flat. Multiple aliases (Pydantic v2
                        only): {'field': ['alt1', 'alt2']} uses AliasChoices
                        for validation. Example: {'User.name': 'user_name',
                        'id': 'id_'} generates `id_: ... = Field(alias='id')`.
  --custom-file-header CUSTOM_FILE_HEADER
                        Custom file header
  --custom-file-header-path CUSTOM_FILE_HEADER_PATH
                        Custom file header file path
  --custom-formatters-kwargs CUSTOM_FORMATTERS_KWARGS
                        Custom formatter kwargs as inline JSON or a JSON file
                        path.
  --custom-template-dir CUSTOM_TEMPLATE_DIR
                        Custom template directory
  --default-values DEFAULT_VALUES
                        Default value overrides as inline JSON or a JSON file
                        path. Supports hierarchical formats: Flat: {'field':
                        value} applies to all occurrences. Scoped:
                        {'ClassName.field': value} applies to specific class.
                        Priority: scoped > flat. Note: Scoped keys use the
                        generated class name for JSON Schema/OpenAPI. Required
                        fields remain required unless --use-default is also
                        specified. Example: {'User.status': 'active', 'page':
                        1, 'limit': 10}
  --encoding ENCODING   The encoding of input and output (default: utf-8)
  --extra-template-data EXTRA_TEMPLATE_DATA
                        Extra template data for output models as inline JSON
                        or a JSON file path. For OpenAPI and Jsonschema the
                        keys are the spec path of the object, or the name of
                        the object if you want to apply the template data to
                        multiple objects with the same name. If you are using
                        another input file type (e.g. GraphQL), the key is the
                        name of the object. The value is a dictionary of the
                        template data to add.
  --generate-schema-validators
                        Generate Pydantic v2 model validators for JSON Schema
                        rules that cannot be represented as type hints
                        (experimental).
  --schema-validator-base-class-name SCHEMA_VALIDATOR_BASE_CLASS_NAME
                        Set the generated shared Pydantic v2 schema runtime
                        validator base class name.
  --schema-validator-type {pydantic-v2}
                        Select the schema-derived runtime validator backend.
                        'pydantic-v2' generates Pydantic v2 model validators
                        (experimental).
  --use-double-quotes   Model generated with double quotes. Single quotes or
                        your black config skip_string_normalization value will
                        be used without this option.
  --use-type-checking-imports, --no-use-type-checking-imports
                        Allow Ruff to move typing-only imports into
                        TYPE_CHECKING blocks. By default this stays enabled,
                        except for multi-module Ruff formatting of modular
                        Pydantic output where referenced models stay imported
                        at runtime. Use --no-use-type-checking-imports to
                        force runtime imports.
  --validators VALIDATORS
                        Validators configuration as inline JSON or a JSON file
                        path. Defines field validators for Pydantic v2 models.
                        Keys are model names, values contain validator
                        definitions with field, function, and mode.
  --wrap-string-literal
                        Wrap string literal by using black `experimental-
                        string-processing` option (require black 20.8b0 or
                        later)

[36;1mOpenAPI-only options[0m:
  --include-path-parameters
                        Include path parameters in generated parameter models
                        in addition to query parameters (Only OpenAPI)
  --openapi-include-info-version
                        Emit OpenAPI info.version as OPENAPI_INFO_VERSION in
                        generated models
  --openapi-include-paths PATTERN [PATTERN ...]
                        Include only OpenAPI paths matching fnmatch patterns.
                        Use wildcards: '*' matches any chars, '?' matches
                        single char. Example: '/users/*' '/products'. Requires
                        '--openapi-scopes' to include 'paths'.
  --openapi-scopes {schemas,paths,tags,parameters,webhooks,requestbodies} [{schemas,paths,tags,parameters,webhooks,requestbodies} ...]
                        Scopes of OpenAPI model generation (default: schemas)
  --read-only-write-only-model-type {request-response,all}
                        Model generation for readOnly/writeOnly fields:
                        'request-response' = Request/Response models only (no
                        base model), 'all' = Base + Request + Response models.
  --use-operation-id-as-name
                        use operation id of OpenAPI as class names of models
  --use-status-code-in-response-name
                        Include HTTP status code in response model names
                        (e.g., ResourceGetResponse200,
                        ResourceGetResponseDefault)
  --validation          Deprecated: The `--validation` option is deprecated
                        and will be removed in a future release. Use --field-
                        constraints instead.

[36;1mGraphQL-only options[0m:
  --graphql-no-typename
                        Exclude __typename field from generated GraphQL
                        models. Useful when using generated models for GraphQL
                        mutations.

[36;1mGeneral options[0m:
  --check               Verify generated files are up-to-date without
                        modifying them. Exits with code 1 if differences
                        found, 0 if up-to-date. Useful for CI to ensure
                        generated code is committed.
  --debug               show debug message (require "debug". `$ pip install
                        'datamodel-code-generator[debug]'`)
  --disable-warnings    disable warnings
  --generate-cli-command
                        Generate CLI command from pyproject.toml configuration
                        and exit
  --generate-prompt [QUESTION]
                        Generate a prompt for consulting LLMs about CLI
                        options. Optionally provide your question as an
                        argument. Pipe to CLI tools (e.g., `| claude -p`, `|
                        codex exec`) or copy to clipboard (e.g., `| pbcopy`,
                        `| xclip`) for web LLM chats.
  --generate-pyproject-config
                        Generate pyproject.toml configuration from the
                        provided CLI arguments and exit
  --ignore-pyproject    Ignore pyproject.toml configuration
  --list-deprecations [{table,json,markdown}]
                        List registered deprecations and scheduled breaking
                        changes, then exit.
  --list-experimental [{table,json,markdown}]
                        List registered experimental features, then exit.
  --no-color            disable colorized output
  --output-format {text,json}
                        Format for command output (default: text). Use json
                        for structured output when supported.
  --output-format-json-schema {config,generate-prompt,generation,model-metadata,structured-output}
                        Output JSON Schema for the selected JSON output or
                        JSON configuration format and exit.
  --profile PROFILE     Use a named profile from pyproject.toml
                        [tool.datamodel-codegen.profiles.<name>]
  --version             show version
  --watch               Watch input file(s) for changes and regenerate output
                        automatically
  --watch-delay WATCH_DELAY
                        Debounce delay in seconds for watch mode (default:
                        0.5)
  -h, --help            show this help message and exit

Documentation: https://datamodel-code-generator.koxudaxi.dev
Agent skill: https://datamodel-code-generator.koxudaxi.dev/coding-agent-skill/
GitHub: https://github.com/koxudaxi/datamodel-code-generator

```

## Agent Task

Recommend a final CLI command for the user's schema and target runtime. Include:
- Final `datamodel-codegen` command in a shell code block.
- Brief explanation for each selected option.
- Rejected alternatives with the reason they do not fit.
- Verification command, such as `datamodel-codegen ... --output models.py --check` (`--check` requires `--output`) or a diff against expected output.

## Decision Checklist

- Input type: auto-detected schema/data, OpenAPI, AsyncAPI, JSON Schema, MCP tools, XML Schema, Protocol Buffers, Avro, GraphQL, CSV, Python input model, or raw JSON/YAML/dict data.
- Output model type: `pydantic_v2.BaseModel`, `pydantic_v2.dataclass`, `dataclasses.dataclass`, `typing.TypedDict`, or `msgspec.Struct`.
- Python/Pydantic version: align `--target-python-version`, `--output-model-type`, and `--target-pydantic-version` when generating Pydantic v2 models.
- Strictness: choose `--strict-types` values, `--strict-nullable`, `--field-constraints`, and `--extra-fields`.
- Aliases/naming: decide between API-compatible aliases and normalized names such as `--snake-case-field`.
- Module layout: choose one file or an output directory with `--module-split-mode` and reuse options.
- Structured output: use `--output-format json` for machine-readable prompt or generation output, `--emit-model-metadata` for generated model maps, and `--output-format-json-schema` when a tool needs a validation schema.
- Runtime model base: use `--base-class` for a custom base class; it is separate from `--output-model-type`.
- Validation constraints: prefer `--field-constraints`; add `--use-annotated` for Pydantic v2.

## Common Recipes

- Strict Pydantic v2: `--output-model-type pydantic_v2.BaseModel --target-pydantic-version 2.11 --use-annotated --field-constraints`, plus needed `--strict-types` values.
- OpenAPI request/response models: `--input-file-type openapi --openapi-scopes schemas paths --read-only-write-only-model-type request-response`.
- TypedDict modern syntax: `--output-model-type typing.TypedDict --target-python-version 3.12 --use-standard-collections --use-union-operator`.
- Multi-module OpenAPI output: set `--output` to a directory and use `--module-split-mode single --all-exports-scope recursive --use-exact-imports`.
- Machine-readable agent flow: run `--generate-prompt --output-format json` first, then validate tool integration with `--output-format-json-schema generate-prompt` or `structured-output`.

## Important Option Relationships

- `--use-annotated` also enables `--field-constraints`; prefer it for constrained Pydantic v2 fields.
- `--openapi-include-paths` only has an effect when `--openapi-scopes paths` is included.
- `--strict-types` requires one or more values: `str`, `int`, `float`, `bool`, or `bytes`.
- `--use-specialized-enum` requires `--target-python-version >= 3.11`.
- `--output-format json` is supported for generation, `--generate-prompt`, and `--check`; not for `--watch`.
- `--output-format-json-schema` accepts `config`, `generate-prompt`, `generation`, `model-metadata`, or `structured-output`; use `config` for JSON configuration schemas.
- `--validation` is deprecated; use `--field-constraints` for generated Field constraints.

## Instructions

Based on the above information, propose the smallest datamodel-codegen
command that satisfies the question or use case. Preserve current options
unless they conflict with the goal or another option. Include:

1. Final CLI command to run
2. Reasons for each non-obvious added or changed option
3. Current options that should remain unchanged
4. Options considered but rejected, with a short reason
5. Verification command that validates the generated CLI or output
