### Example Output of Generated Resource List

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/generatecodedata

Shows the format of the generated resources.txt file. Each line contains the resource tag (e.g., 'item') and its corresponding path, separated by a comma.

```Text
item,/ui/icon1.jpg
item,/ui/icon2.jpg
```

--------------------------------

### Generate Unified Resource List from Configuration

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/generatecodedata

Command line example to generate a list of all resource addresses tagged in the configuration. The `--output:data:resource_list_file` parameter specifies the output file name.

```Shell
--gen_types data_resources --output:data:resource_list_file resources.txt
```

--------------------------------

### Generate Client Code and Data (Bin Format) with Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/commandtools

Command-line example to generate client-side code and data in binary format using Luban. It specifies input/output directories, `code_cs_unity_bin` and `data_bin` gen_types, and targets the 'client' service group, including test data.

```Batch
dotnet d:\\tools\\Luban.Client\\Luban.Client.dll ^
    -h 127.0.0.1 ^
    -p 8899 ^
    -j cfg ^
    -- ^
    --define_file d:\\raw_config\\defines\\__root__.xml ^
    --input_data_dir d:\\raw_configs\\datas ^
    --output_code_dir d:\\client\\Assets\\Gen ^
    --output_data_dir d:\\client\\Assets\\StreamingAssets\\GameData ^
    --gen_types code_cs_unity_bin,data_bin ^
    --service client
```

--------------------------------

### Load Protobuf2 Binary Data in C#

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/generatecodedata

Demonstrates how to parse and load binary data generated with Protobuf2 format into a C# object, using the `ParseFrom` method from the generated parser class.

```C#
var tbItem = ItemTbItem.Parser.ParseFrom(File.OpenRead("pb_datas/item_tbitem.bytes"));
```

--------------------------------

### Generate Server Code and Data (JSON Format) with Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/commandtools

Command-line example to generate server-side code and data in JSON format using Luban. It specifies input/output directories, `code_cs_json` and `data_json` gen_types, targets the 'server' service group, and includes test data.

```Batch
dotnet d:\\tools\\Luban.Client\\Luban.Client.dll ^
    -h 127.0.0.1 ^
    -p 8899 ^
    -j cfg ^
    -- ^
    --define_file d:\\raw_config\\defines\\__root__.xml ^
    --input_data_dir d:\\raw_configs\\datas ^
    --output_code_dir d:\\server\\src\\Gen ^
    --output_data_dir d:\\server\\GameData ^
    --gen_types code_cs_json,data_json ^
    --service server
```

--------------------------------

### Lua Data Example for DemoType2

Source: https://luban.doc.code-philosophy.com/docs/help/faq/manual/otherdatasource

Demonstrates DemoType2 data representation in Lua. It shows the return statement for loading, set and map syntax, and the _type_ property for polymorphic beans.

```Lua
return
{
  x1 = false,
  x2 = 2,
  x3 = 128,
  x4 = 1122,
  x5 = 112233445566,
  x6 = 1.3,
  x7 = 1122,
  x10 = "yf",
  x12 = {x1=1},
  x13 = "D",
  x14 = { _type_="DemoD2", x1 = 1, x2=3},
  t1 = "1970-01-01 00:00:00",
  k1 = {1,2},
  k2 = {2,3},
  k8 = {[2]=10,[3]=12},
  k9 = { {y1=1,y2=true}, {y1=10,y2=false} },
  k15 = { { _type_="DemoD2", x1 = 1, x2=3} },
}
```

--------------------------------

### Configure C# Vector Types for Unity

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/generatecodedata

Command line option to change the generated C# vector types from `System.Numerics.Vector` to `UnityEngine.Vector` for better compatibility with Unity projects.

```Shell
--cs:use_unity_vector
```

--------------------------------

### Example YAML Data Configuration for Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/datasource

This YAML snippet provides an example of data configuration for Luban, showcasing various data types such as boolean, integer, float, string, nested objects, lists, and polymorphic bean types using the '$type' property.

```YAML
x1: true
x2: 3
x3: 128
x4: 40
x5: 11223344
x6: 1.2
x7: 1.23432
x10: hq
x12:
  x1: 10
x13: B
x14:
  $type: DemoD2
  x1: 1
  x2: 2
s1:
  key: "/key32"
  text: aabbcc22
v2:
  x: 1
  y: 2
v3:
  x: 1.1
  y: 2.2
  z: 3.4
v4:
  x: 10.1
  y: 11.2
  z: 12.3
  w: 13.4
t1: '1970-01-01 00:00:00'
k1:
- 1
- 2
k2:
- 2
- 3
k8:
- - 2
  - 2
- - 4
  - 10
k9:
- y1: 1
  y2: true
- y1: 2
  y2: false
k15:
- $type: DemoD2
  x1: 1
  x2: 2
```

--------------------------------

### Generate Unity C# Binaries with Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/3.x/manual/commandtools

Example command to generate C# code and binary data for Unity projects using Luban. This script configures the workspace, Luban DLL path, and data table root, then executes Luban with specific code and data targets, output directories, path validation, and localization settings.

```Batch
set WORKSPACE=..\..

set LUBAN_DLL=%WORKSPACE%\Tools\Luban\Luban.dll
set CONF_ROOT=%WORKSPACE%\DataTables

dotnet %LUBAN_DLL% ^
    -t all ^
    -c cs-bin ^
    -d bin  ^
    --conf %CONF_ROOT%\luban.conf ^
    -x outputCodeDir=Assets/Gen ^
    -x outputDataDir=..\GenerateDatas\bytes ^
    -x pathValidator.rootDir=%WORKSPACE%\Projects\Csharp_Unity_bin ^
    -x l10n.textProviderFile=*@%WORKSPACE%\DataTables\Datas\l10n\texts.json
```

--------------------------------

### Generate Dotnet C# Binaries with Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/3.x/manual/commandtools

Example command to generate C# code and binary data for .NET projects using Luban. This script configures the workspace, Luban DLL path, and data table root, then executes Luban with specific code and data targets, output directories, path validation, and localization settings.

```Batch
set WORKSPACE=..\..

set LUBAN_DLL=%WORKSPACE%\Tools\Luban\Luban.dll
set CONF_ROOT=%WORKSPACE%\DataTables

dotnet %LUBAN_DLL% ^
    -t all ^
    -c cs-bin ^
    -d bin  ^
    --conf %CONF_ROOT%\luban.conf ^
    -x outputCodeDir=Gen ^
    -x outputDataDir=..\GenerateDatas\bytes ^
    -x pathValidator.rootDir=%WORKSPACE%\Projects\Csharp_Unity_bin ^
    -x l10n.textProviderFile=*@%WORKSPACE%\DataTables\Datas\l10n\texts.json
```

--------------------------------

### Generate Client Code and Data (JSON Format, Exclude Tags) with Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/commandtools

Command-line example to generate client-side code and data in JSON format using Luban. It specifies input/output directories, `code_cs_unity_json` and `data_json` gen_types, targets the 'client' service group, and excludes data with 'dev' and 'test' tags.

```Batch
dotnet d:\\tools\\Luban.Client\\Luban.Client.dll ^
    -h 127.0.0.1 ^
    -p 8899 ^
    -j cfg ^
    -- ^
    --define_file d:\\raw_config\\defines\\__root__.xml ^
    --input_data_dir d:\\raw_configs\\datas ^
    --output_code_dir d:\\client\\Assets\\Gen ^
    --output_data_dir d:\\client\\Assets\\StreamingAssets\\GameData ^
    --gen_types code_cs_unity_json,data_json ^
    --service client ^
    --export_exclude_tags dev,test
```

--------------------------------

### Generate Unity C# JSON Data with Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/3.x/manual/commandtools

Example command to generate C# code and JSON data for Unity projects using Luban. This script sets up the environment variables and then runs Luban to produce C# code and JSON data, specifying output paths and localization file.

```Batch
set WORKSPACE=..\..

set GEN_CLIENT=%WORKSPACE%\Tools\Luban\Luban.dll
set CONF_ROOT=%WORKSPACE%\DataTables

dotnet %GEN_CLIENT% ^
    -t all ^
    -c cs-simple-json ^
    -d json  ^
    --conf %CONF_ROOT%\luban.conf ^
    -x outputCodeDir=Assets/Gen ^
    -x outputDataDir=..\GenerateDatas\json ^
    -x pathValidator.rootDir=D:\workspace2\luban_examples\Projects\Csharp_Unity_bin ^
    -x l10n.textProviderFile=*@D:\workspace2\luban_examples\DataTables\Datas\l10n\texts.json
```

--------------------------------

### JSON Data Example for DemoType2

Source: https://luban.doc.code-philosophy.com/docs/help/faq/manual/otherdatasource

Illustrates how to represent DemoType2 data in JSON. Special considerations for set, map, and polymorphic bean types are shown, including the use of $type for polymorphism.

```JSON
{
  "x1":true,
  "x2":3,
  "x3":128,
  "x4":1,
  "x5":11223344,
  "x6":1.2,
  "x7":1.23432,
  "x10":"hq",
  "x12": { "x1":10},
  "x13":"B",
  "x14":{"$type": "DemoD2", "x1":1, "x2":2},
  "t1":"1970-01-01 00:00:00",
  "k1":[1,2],
  "k2":[2,3],
  "k7":[2,3],
  "k8":[[2,2],[4,10]],
  "k9":[{"y1":1, "y2":true},{"y1":2, "y2":false}],
  "k15":[{"_type_": "DemoD2", "x1":1, "x2":2}]
}
```

--------------------------------

### YAML Data Format Example

Source: https://luban.doc.code-philosophy.com/docs/help/faq/3.x/manual/otherdatasource

Illustrates a sample YAML data structure, highlighting its similarity to JSON and demonstrating set, map, and polymorphic bean type representations. It shows how various data types and complex structures are defined in YAML.

```YAML
x1: true
x2: 3
x3: 128
x4: 40
x5: 11223344
x6: 1.2
x7: 1.23432
x10: hq
x12:
  x1: 10
x13: B
x14:
  $type: DemoD2
  x1: 1
  x2: 2
t1: '1970-01-01 00:00:00'
k1:
- 1
- 2
k2:
- 2
- 3
k8:
- - 2
  - 2
- - 4
  - 10
k9:
- y1: 1
  y2: true
- y1: 2
  y2: false
k15:
- $type: DemoD2
  x1: 1
  x2: 2
```

--------------------------------

### Generate Only Data for JSON Format

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/generatecodedata

Command line option to generate only the data files in JSON format, excluding code generation.

```Shell
--gen_types data_json
```

--------------------------------

### XML Enum Definition and Attributes

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/define

Describes the `enum` definition for creating enumerations. It provides examples of basic and flagged enums, detailing attributes for the enum itself and for individual `var` (enum item) elements.

```XML
<enum name="Color">
    <var name="RED" alias="红" value="1"/>
    <var name="GREEN" alias="绿" value="2"/>
   <var name="BLUE" alias="蓝" value="3"/>
</enum>

<enum name="AccessMode" flags="1" tags="key1=value1#key2=value2" comment="访问方式" unique="1">
    <var name="READ" value="1" tags="key1=value1#k2=v2" comment="读"/>
    <var name="WRITE" value="2"/>
    <var name="READ_WRITE" value="READ|WRITE"/>
</enum>
```

```APIDOC
enum.name:
  Required. Enum name. Namespace is the full namespace of the current module (including parent modules).
enum.flags:
  Optional. Whether it's a bit flag type. Defaults to false. If 1 or true, allows READ|WRITE syntax in configuration data.
enum.tags:
  Optional. Tags. Format: "key1=value2#key2=value2#...". Typically used with custom template generation.
enum.unique:
  Optional. Whether enum values are unique. Defaults to true.
enum.comment:
  Optional. Comment. If not empty, included in generated code.
enum.var.name:
  Required. Enum item name.
enum.var.alias:
  Optional. Alias. For planners to fill data, convenient for those less familiar with English.
enum.var.value:
  Optional. Enum value. If empty, value is previous item's value + 1. If first item, value is 0.
enum.var.tags:
  Optional. Tags. Typically used with custom template generation.
enum.var.comment:
  Optional. Comment. If not empty, included when generating enum items. If empty and alias is defined, alias will be used as comment.
```

--------------------------------

### Example Lua Data Configuration for Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/datasource

This Lua snippet illustrates how data is structured for Luban, including boolean, integer, float, string, text tables, nested tables, set-like tables, map-like tables with arbitrary keys, and polymorphic bean types using the '_type_' property. Note the 'return' keyword at the beginning.

```Lua
return
{
  x1 = false,
  x2 = 2,
  x3 = 128,
  x4 = 1122,
  x5 = 112233445566,
  x6 = 1.3,
  x7 = 1122,
  x10 = "yf",
  t1 = {key="/key/ab1", text="apple"},
  x12 = {x1=1},
  x13 = "D",
  x14 = { _type_="DemoD2", x1 = 1, x2=3},
  v2 = {x= 1,y = 2},
  v3 = {x=0.1, y= 0.2,z=0.3},
  v4 = {x=1,y=2,z=3.5,w=4},
  t1 = "1970-01-01 00:00:00",
  k1 = {1,2},
  k2 = {2,3},
  k8 = {[2]=10,[3]=12},
  k9 = { {y1=1,y2=true}, {y1=10,y2=false} },
  k15 = { { _type_="DemoD2", x1 = 1, x2=3} },
}
```

--------------------------------

### Manually Specify Output Data File Extension

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/generatecodedata

Command line option to override the default file extension for generated data files, allowing users to set a custom suffix.

```Shell
--data_file_extension xxx
```

--------------------------------

### Example XML Data Configuration for Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/datasource

This XML snippet shows how data can be represented for Luban, including basic types, nested elements, and arrays. It also demonstrates the 'type' attribute for polymorphic beans and different ways to represent lists and maps.

```XML
<data>
  <x1>true</x1>
  <x2>4</x2>
  <x3>128</x3>
  <x4>1</x4>
  <x5>112233445566</x5>
  <x6>1.3</x6>
  <x7>1112232.43123</x7>
  <x10>yf</x10>
  <x12> <x1>1</x1> </x12>
  <x13>C</x13>
  <x14 type="DemoD2">  <x1>1</x1>  <x2>2</x2> </x14>
  <v2>1,2</v2>
  <v3>1.2,2.3,3.4</v3>
  <v4>1.2,2.2,3.2,4.3</v4>
  <t1>1970-01-01 00:00:00</t1>
  <k1> <item>1</item> <item>2</item> </k1>
  <k2> <item>1</item> <item>2</item> </k2>
  <k8>
      <item> <key>2</key><value>10</value></item>
      <item> <key>3</key><value>30</value></item>
  </k8>
  <k9>
      <item> <y1>1</y1> <y2>true</y2> </item>
      <item> <y1>2</y1> <y2>false</y2> </item>
  </k9>
  <k15>
      <item type="DemoD2"> <x1>1</x1> <x2>2</x2> </item>
  </k15>
</data>
```

--------------------------------

### Set Custom Code Naming Convention

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/generatecodedata

Command line option to customize the naming style of generated code fields. Setting it to 'none' makes field names identical to their definitions.

```Shell
--naming_convention_bean_member none
```

--------------------------------

### XML Module Definition and Nesting

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/define

Explains the `module` definition, including the `name` attribute for module naming, which can be empty or multi-level. It also covers nested sub-modules and how type namespaces are inherited within modules, showing how classes like Abc and Def get their full names.

```XML
<module name="xx">
   <module name="yy">
     <bean name="Abc"/>
   </module>
   <module name="zz">
     <bean name="Def"/>
   </module>
</module>
```

--------------------------------

### Generate Only Code for C# Unity JSON Project

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/generatecodedata

Command line option to generate only the code files for a C# Unity project using JSON data format, excluding data generation.

```Shell
--gen_types code_cs_unity_json
```

--------------------------------

### Define Resource-Tagged String Fields in Configuration

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/generatecodedata

Illustrates how to tag a string field as a resource address in a bean definition using the '#res=xxx' attribute. This allows Luban to unify and export these resource paths.

```XML
  <bean name="TestRes">
    <var name="icon" type="string#res=item"/>
  </bean>
```

--------------------------------

### Luban Command-line Configuration for Text Type Validation

Source: https://luban.doc.code-philosophy.com/docs/help/faq/3.x/manual/l10n

Example command-line parameters to enable and configure text type validation in Luban. It sets the default text provider, specifies the path to the localization text file (JSON format requiring a '*@' prefix), and defines the field name for the localization key. These parameters are crucial for enabling text key validity checks.

```Shell
-x l10n.provider=default ^
  -x "l10n.textFile.path=*@D:\\workspace2\\luban_examples\\DataTables\\Datas\\l10n\\texts.json" ^
  -x l10n.textFile.keyFieldName=key
```

--------------------------------

### XML Data Format Example

Source: https://luban.doc.code-philosophy.com/docs/help/faq/3.x/manual/otherdatasource

Demonstrates a sample XML data structure with various element types, including boolean, integer, float, string, nested elements, and lists of items. It showcases how different data types are represented within the XML schema.

```XML
<data>
  <x1>true</x1>
  <x2>4</x2>
  <x3>128</x3>
  <x4>1</x4>
  <x5>112233445566</x5>
  <x6>1.3</x6>
  <x7>1112232.43123</x7>
  <x10>yf</x10>
  <x12> <x1>1</x1> </x12>
  <x13>C</x13>
  <x14 type="DemoD2">  <x1>1</x1>  <x2>2</x2> </x14>
  <k1> <item>1</item> <item>2</item> </k1>
  <k2> <item>1</item> <item>2</item> </k2>
  <k8>
      <item> <key>2</key><value>10</value></item>
      <item> <key>3</key><value>30</value></item>
  </k8>
  <k9>
      <item> <y1>1</y1> <y2>true</y2> </item>
      <item> <y1>2</y1> <y2>false</y2> </item>
  </k9>
  <k15>
      <item type="DemoD2"> <x1>1</x1> <x2>2</x2> </item>
  </k15>
</data>
```

--------------------------------

### Example JSON Data Configuration for Luban

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/datasource

This JSON snippet demonstrates various data types and structures supported by Luban, including boolean, integer, float, string, text objects, nested objects, arrays (set type), map-like arrays, and polymorphic bean types using the '$type' property.

```JSON
{
  "x1":true,
  "x2":3,
  "x3":128,
  "x4":1,
  "x5":11223344,
  "x6":1.2,
  "x7":1.23432,
  "x10":"hq",
  "t1": {"key":"/key/xx1","text":"apple"},
  "x12": { "x1":10},
  "x13":"B",
  "x14":{"$type": "DemoD2", "x1":1, "x2":2},
  "v2":{"x":1, "y":2},
  "v3":{"x":1.1, "y":2.2, "z":3.4},
  "v4":{"x":10.1, "y":11.2, "z":12.3, "w":13.4},
  "t1":"1970-01-01 00:00:00",
  "k1":[1,2],
  "k2":[2,3],
  "k7":[2,3],
  "k8":[[2,2],[4,10]],
  "k9":[{"y1":1, "y2":true},{"y1":2, "y2":false}],
  "k15":[{"$type": "DemoD2", "x1":1, "x2":2}]
}
```

--------------------------------

### luban-client Command-Line General Parameters

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/commandtools

This section details the general command-line parameters for `luban-client.dll`, including options for host, port, job type, log level, cache meta file, watch directories, and help. It provides an overview of the basic invocation syntax and available global flags.

```APIDOC
dotnet Luban.Client.dll [-h <host>] [-p <port>] [-l <log level>] [-c <cache meta file>] [-w <watch dirs>] [-h ] -j cfg -- <job options>

参数介绍：
-h,--host <host>                可选参数。 luban-server的地址。默认为 127.0.0.1
-p,--port <port>                可选参数。 luban-server的端口。默认为 8899
-j,--job <job>                  必选参数。 生成类型。目前支持的生成类型有: cfg,proto,db。 生成配置请取cfg。
-l,--loglevel <log level>       可选参数。 日志级别。默认为INFO。有效值有: TRACE,DEBUG,INFO,WARN,ERROR,FATAL,OFF
-c,--cachemetafile <meta file>  可选参数。 meta缓存文件名。 默认为 .cache.meta
-w,--watch <dir1;dir2...>       可选参数。 监测目录或者目录列表，以逗号';'分隔。当开启此选项后，生成结束后不会退出程序，而是进入自动生成模式。
                                          监听到目标目录发生变化后，自动重新运行生成。省去改动后手动运行生成脚本的麻烦。
--generateonly                  可选参数。 仅生成。不从服务器下载生成结果。可以用于检查服务器是否能成功生成。
-h,--help                       可选参数。 显示帮助信息
--  <job options>               必选参数。 从此参数起，便是 不同job的特有选项
```

--------------------------------

### luban-client cfg Job-Specific Options

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/commandtools

This section outlines the specific command-line options available when using the `cfg` job type with `luban-client.dll`. It covers parameters for defining files, input/output directories, generation types, validation, data output formats, template settings, naming conventions, localization, and language-specific configurations.

```APIDOC
cfg的<job options>介绍：

-d,--define_file <root file>            必选参数。 根定义文件名。
--input_data_dir  <input data dir>      必选参数。 配置数据文件根目录。
--input:convert:dir <dir>               可选参数。 执行json、lua、xlsx之类数据格式转换时，提供的数据源，覆盖table中默认的input参数。
-c,--output_code_dir <output code dir>  可选参数。 生成代码文件的目录。
-s,--service                            必选参数。生成分组目标。一般来说，会定义client,server,editor等好几个目标，不同目标的生成内容不同。

--gen_types <type1,type2,,,>  必选参数。生成任务类型。既可以是生成代码也可以是生成数据或者其他。
                              目前支持的有 code_cs_bin,code_cs_unity_bin,code_cs_dotnet_json,code_cs_unity_json,
                                  code_cs_unity_editor_json,code_lua_bin,code_java_bin,code_go_bin,
                                  code_go_json,code_cpp_bin,code_cpp_ue_editor_json,code_python27_json,
                                  code_python3_json, code_gdscript_json, code_typescript_bin,code_typescript_json,code_rust_json,
                                  code_protobuf2,code_protobuf3,code_template,code_flatbuffers,
                                  data_bin,data_bidx,data_lua,data_json,data_json_monolithic,data_bson,data_yaml,
                                  data_template,data_protobuf_bin,data_protobuf_json,data_flatbuffers_json,
                                  convert_json,convert_lua,convert_xlsx,convert_template

--validate_root_dir <path validate root dir>. 可选参数。 配置path检查的根目录。

--output_data_dir <output data dir>     可选参数。 导出的数据文件的目录。只生成代码时可不指定。

--output:data:compact_json                   可选参数。默认导出的json格式为对齐后的优雅格式，使用此参数后导出紧凑的不带空格和换行的格式。
--output:data:file_extension  <output data file extension>     可选参数。 导出数据文件的后缀。默认按照生成类型自动选择。
--output:exclude_tags <tag1,tag2>           可选参数。导出时排除包含这些tag的数据
--output:tables <table1,table2...>          可选参数。手动指定导出哪些表。覆盖group中设置
--output:include_tables <table1,table2...>  可选参数。除了group中设置外，额外新增表。
--output:exclude_tables <table1,table2...>  可选参数。排除group中指定的表。

--output:convert:file_extension <extension> 可选参数。 convert数据文件的后缀。默认按照模板名猜测。

--template:code:dir <dir name>              可选参数。自定义额外代码模板的目录名
--template:data:file  <template name>       可选参数。数据模板的名称（不包含后缀），当gen_types包含 data_template时必须指定。
--template:convert:file <template name>     可选参数。convert模板的名称（不包含后缀），当gen_types包含convert_template时必须指定。

--naming_convention:module <convention>     可选参数。生成代码中模板名的命名约定，可用值为 language_recommend,none,camelCase,PascalCase,under_scores。 默认为language_recommend，即选择与相应语言推荐的命名约定风格。 此选项目前未生效。
--naming_convention:bean_member <convention> 可选参数。生成代码中bean类型字段名的命名约定，可用值为 language_recommend,none,camelCase,PascalCase,under_scores。 默认为language_recommend。
--naming_convention:enum_member <convention> 可选参数。生成代码中enum类型名的命名约定，可用值为 language_recommend,none,camelCase,PascalCase,under_scores。 默认为language_recommend。此选项目前未生效。
--access_bean_member <access mode>  可选参数。 bean属性的访问方式。可用值为language_recommend,variable,getter_setter,property。默认为 language_recommend。此字段目前未生效。

--l10n:timezone <timezone>           可选参数。 指定所在时区。影响datetime类型转换为utc时间。 默认为中国北京时间。
--l10n:input_text_files <file1,file2..> 可选参数。 本地化的文本映射表。可以有多个。
--l10n:text_field_name <field name>     可选参数。 文本映射表中，目标映射列的列名，默认为text
--l10n:output_not_translated_text_file <file> 可选参数。 未被本地化映射的text key和value的输出文件。不提供该参数则不生成
--l10n:patch <patch name>                  可选参数。当前需要生成的分支名称。
--l10n:patch_input_data_dir <patch data root dir> 可选参数。分支数据的根目录。

--typescript:bright_require_path <path>    可选参数。生成typescript代码引用的bright模块的路径
--typescript:bright_package_name <packet>  可选参数。生成typescript代码以包形式引用bright库的路径
--typescript:use_puerts_bytebuf            可选参数。生成typescript代码中使用puerts中导入的c# Bytebuf类。
--cs:use_unity_vector                      可选参数。生成c#代码中，使用UnityEngine.Vector{2,3,4}作为Vector数据类型。
--go:bright_module_name <module path>      可选参数。生成go代码时，bright module的import目录。

--external:selectors  <selector1,selector2 ...>       可选参数。 外部类选择器，可以多个。selector必须是root.xml中externalselector中定义的选择器之一。
```

--------------------------------

### Luban gen_types Parameter Reference

Source: https://luban.doc.code-philosophy.com/docs/help/faq/1.x/manual/commandtools

Detailed reference for the `gen_types` parameter, specifying supported types for code generation (e.g., C#, Lua, Java, Go, C++, Python, TypeScript, Rust, Protobuf, Flatbuffers) and data generation (e.g., Bin, Lua, JSON, BSON, YAML, XML, Protobuf, Flatbuffers), as well as source data conversion types.

```APIDOC
gen_types:
  Code Generation:
    - code_cs_bin: Generates code for .NET platform to read binary data. Uses System.Numerics.Vector{2,3,4}.
    - code_cs_unity_bin: Generates code for Unity to read binary data. Uses UnityEngine.Vector{2,3,4}.
    - code_cs_dotnet_json: Generates code for .NET platform to read JSON data. Uses System.Numerics.Vector{2,3,4}.
    - code_cs_unity_json: Generates code for Unity to read JSON data. Uses UnityEngine.Vector{2,3,4}.
    - code_cs_unity_editor_json: Generates code for Unity editor development. Supports loading/saving single records to JSON files.
    - code_lua_bin: Generates Lua code to read binary data.
    - code_java_bin: Generates Java code to read binary data.
    - code_java_json: Generates Java code to read JSON data.
    - code_go_bin: Generates Go code to read binary data.
    - code_go_json: Generates Go code to read JSON data.
    - code_cpp_bin: Generates C++ code to read binary data.
    - code_cpp_ue_editor_json: Generates code for UE4 editor development. Supports loading/saving single records to JSON files.
    - code_python27_json: Generates Python 2.7 code to read JSON data.
    - code_python3_json: Generates Python 3 code to read JSON data.
    - code_gdscript_json: Generates GDScript code to read JSON data.
    - code_typescript_bin: Generates TypeScript code to read binary data.
    - code_typescript_json: Generates TypeScript code to read JSON data.
    - code_rust_json: Generates Rust code to read JSON data.
    - code_protobuf2: Generates Protobuf 2 schema files.
    - code_protobuf3: Generates Protobuf 3 schema files.
    - code_template: Indicates use of custom code templates.
    - code_flatbuffers: Generates Flatbuffers schema files.
  Data Generation:
    - data_bin: Exports data in binary format.
    - data_bidx: Exports binary index data for record-level lazy loading.
    - data_lua: Exports data in Lua format.
    - data_json: Exports data in JSON format.
    - data_json_monolithic: Exports all table JSON data into a single JSON file.
    - data_bson: Exports data in BSON format.
    - data_yaml: Exports data in YAML format.
    - data_xml: Exports data in XML format.
    - data_template: Indicates use of custom data templates.
    - data_protobuf_bin: Exports Protobuf binary data.
    - data_protobuf_json: Exports Protobuf 3 JSON data.
    - data_flatbuffers_json: Exports Flatbuffers JSON data.
    - data_resources: Exports all data with 'res' tags.
  Source Data Conversion:
    - convert_json: Converts all source data to JSON source format (each record in a separate file).
    - convert_lua: Converts all source data to Lua source format (each record in a separate file).
    - convert_xlsx: Converts all source data to XLSX format (each table in a separate file).
    - convert_template: Indicates use of custom conversion templates (each record in a separate file).
```

--------------------------------

### Luban xargs Command Line Parameters

Source: https://luban.doc.code-philosophy.com/docs/help/faq/3.x/manual/commandtools

Detailed list of customizable command-line parameters for Luban's pipeline modules, accessed via `-x --xargs`. These parameters allow fine-grained control over output directories, naming conventions, code styles, data exporters, post-processors, and localization settings.

```APIDOC
Parameter: {codeTarget}.outputCodeDir
  Description: 代码目标的输出目录
  Example: -x outputCodeDir=/my/output/dir

Parameter: {dataTarget}.outputDataDir
  Description: 数据目标的输出目录
  Example: -x outputDataDir=/my/output/dir

Parameter: codeStyle
  Description: 代码目标的命名风格，内置实现的Code Target都会自动设置与目标语言相匹配的codeStyle，不需要显式指定
  Available Values: none, csharp-default, java-default, go-default, lua-default, typescript-default, cpp-default, python-default, dart-default
  Example: -x codeStyle=csharp-default

Parameter: namingConvention.{codeTarget}.{location}
  Description: codeTarget为`--codeTarget`参数中指定的target名。location为风格位置，可选值为namespace、type、method、property、field、enumItem，详见代码风格。该参数为层级选项，如果不指定{codeTarget}，则对所有target生效
  Available Values: none, pascal, camel, upper, snake
  Example: -x namingConvention.cs-bin.field=pascal

Parameter: dataExporter
  Description: 数据导出器
  Available Values: null, default
  Example: -x dataExporter=default

Parameter: codePostprocess
  Description: 代码后处理器，可以为多个
  Available Values: 未实现任何内置postprocess
  Example: -x codePostProcess=a,b,c

Parameter: dataPostprocess
  Description: 数据后处理器，可以为多个
  Available Values: 未实现任何内置postprocess
  Example: -x dataPostProcess=a,b

Parameter: outputSaver
  Description: 数据保存器，默认为local，即输出到本地目录，如果不想输出任何文件，可以用null
  Available Values: null, local
  Example: -x outputSaver=local

Parameter: outputSaver.{codeTarget|dataTarget}.cleanUpOutputDir
  Description: 输出文件前是否清除outputCodeDir或者outputDataDir目录中多余的文件，默认为true
  Example: -x outputSaver.cs-bin.cleanUpOutputDir=0

Parameter: l10n.provider
  Description: 本地化文本Provider，如果未设置此参数则不进行任何本地化相关操作，包括text校验和静态转换
  Available Values: default
  Example: -x l10n.provider=default

Parameter: l10n.textFile.path
  Description: 本地化文本数据文件，当设置了l10.provider时必填此值
  Example: -x l10n.textFile.path=xxxx

Parameter: l10n.textFile.keyFieldName
  Description: 本地化文本数据文件中数据项key字段的字段名
  Example: -x l10n.textFile.keyFieldName=key

Parameter: l10n.textFile.languageFieldName
  Description: 本地化文本数据文件中数据项对应语言的文本值字段的字段名
  Example: -x l10n.languageFieldName=en

Parameter: l10n.convertTextKeyToValue
  Description: 执行静态本地化，将key替换为对应语言的文本值
  Example: -x l10n.convertTextKeyToValue=1

Parameter: l10n.textListFile
  Description: 输出的配置中所有text key的列表的文件，配合 DataTarget text-list使用
  Example: 

Parameter: pathValidator.rootDir
  Description: path校验器搜索文件所用的根目录
  Example: -x pathValidator.rootDir=/xx/yy

Parameter: {code|data}.lineEnding
  Description: 生成的代码和数据文件的行尾符。该选项只对文本类型的输出文件有效，对于二进制格式如bin、bson之类的格式无效
  Available Values: CR, LF, CRLF (if unspecified, Environment.NewLine is used)
  Example: -x lineEnding=LF, -x code.LineEnding=LF, -x data.lineEnding=LF

Parameter: json.compact
  Description: 是否输出紧凑无缩进的json数据，与json或json2 dataTarget配合使用，默认为0
  Available Values: 0, 1, true, false
  Example: -x compact=1

Parameter: {dataTarget}.fileExt
  Description: 输出数据文件的文件名后缀
  Example: -x bin.fileExt=bin

Parameter: ~~{dataTarget}.outputDataExtension~~
  Description: 输出数据文件的文件名后缀。v2.12.0版本移除，改名为fileExt
  Example: -x bin.outputDataExtension=bin

Parameter: {codeTarget|dataTarget}.fileEncoding
  Description: 输出文件的字符编码
  Example: -x lua.fileEncoding=gb2313
```

--------------------------------

### Luban Supported Code Targets

Source: https://luban.doc.code-philosophy.com/docs/help/faq/3.x/manual/commandtools

Lists the code targets built into Luban, specifying the programming language and the data file format they are designed to read. Each target is optimized for different environments or libraries. Note that code targets must match data targets for successful loading, and separate output directories are required for multiple target generation.

```APIDOC
code target: cs-bin
  description: C#, reads bin format files
code target: cs-simple-json
  description: C#, uses SimpleJSON to read json files, recommended for Unity client
code target: cs-dotnet-json
  description: C#, uses System.Text.Json library to read json files, recommended for dotnet core server
code target: cs-newtonsoft-json
  description: C#, uses Newtonsoft.Json library to read json files
code target: cs-editor-json
  description: C#, reads and saves records as a single json file, suitable for custom editor saving and loading original configuration files
code target: cs-protobuf2
  description: Generates code to load all protobuf bin and json format data, only includes Tables class
code target: cs-protobuf3
  description: Generates code to load all protobuf bin and json format data, only includes Tables class
code target: lua-lua
  description: lua, reads lua format files
code target: lua-bin
  description: lua, reads bin format files
code target: java-bin
  description: java, reads bin format files
code target: java-json
  description: java, uses gson library to read json format files
code target: cpp-bin
  description: cpp, reads bin format files. Removed since v2.3.0
code target: cpp-sharedptr-bin
  description: cpp, uses smart pointers to save dynamically allocated objects, reads bin format files
code target: cpp-rawptr-bin
  description: cpp, uses raw pointers to save dynamically allocated objects, reads bin format files
code target: go-bin
  description: go, reads bin format files
code target: go-json
  description: go, reads json format files
code target: python-json
  description: python, reads json format files
code target: gdscript-json
  description: gdscript, reads json format files. Note, if you develop with C# language, it is recommended to use the more efficient cs-bin format
code target: typescript-bin
  description: typescript, reads json format files
code target: typescript-json
  description: typescript, reads json format files
code target: typescript-protobuf
  description: typescript, generates code to read protobuf format data, only includes Tables class
code target: rust-bin
  description: Generates rust code, reads bin format files
code target: rust-json
  description: Generates rust code, reads json format files
code target: php-json
  description: php, reads json format files
code target: dart-json
  description: Generates dart code, reads json format files
code target: protobuf2
  description: Generates proto2 syntax schema files
code target: protobuf3
  description: Generates proto3 syntax schema files
code target: flatbuffers
  description: Generates flatbuffers schema files
```

--------------------------------

### Luban OutputSaver Configuration

Source: https://luban.doc.code-philosophy.com/docs/help/faq/3.x/manual/commandtools

Describes the available output savers for generated data, including 'local' for saving to disk and 'null' for no output. The 'local' saver is the default, while 'null' is useful for validation without file generation.

```APIDOC
OutputSaver:
  - local: Saves generated files to a local directory (default).
  - null: Performs no operation, useful for validation without file generation.
```