@gozargah/xray-schema 0.0.3 → 0.0.4

package/dist/full/schema.json

@@ -796,7 +796,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema613"
+              "$ref": "#/definitions/__schema619"
             }
           },
           {
@@ -811,7 +811,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema635"
+              "$ref": "#/definitions/__schema641"
             }
           },
           {
@@ -826,7 +826,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema647"
+              "$ref": "#/definitions/__schema653"
             }
           },
           {
@@ -841,7 +841,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema656"
+              "$ref": "#/definitions/__schema662"
             }
           },
           {
@@ -856,7 +856,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema664"
+              "$ref": "#/definitions/__schema670"
             }
           },
           {
@@ -871,7 +871,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema681"
+              "$ref": "#/definitions/__schema687"
             }
           }
         ]
@@ -918,7 +918,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema688"
+              "$ref": "#/definitions/__schema694"
             }
           },
           {
@@ -936,7 +936,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema710"
+              "$ref": "#/definitions/__schema716"
             }
           },
           {
@@ -951,7 +951,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema730"
+              "$ref": "#/definitions/__schema736"
             }
           },
           {
@@ -966,7 +966,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema750"
+              "$ref": "#/definitions/__schema756"
             }
           },
           {
@@ -981,7 +981,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema756"
+              "$ref": "#/definitions/__schema762"
             }
           },
           {
@@ -996,7 +996,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema760"
+              "$ref": "#/definitions/__schema766"
             }
           },
           {
@@ -1011,7 +1011,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema769"
+              "$ref": "#/definitions/__schema775"
             }
           },
           {
@@ -1026,7 +1026,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema783"
+              "$ref": "#/definitions/__schema789"
             }
           },
           {
@@ -1041,7 +1041,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema790"
+              "$ref": "#/definitions/__schema796"
             }
           },
           {
@@ -1056,7 +1056,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema804"
+              "$ref": "#/definitions/__schema810"
             }
           },
           {
@@ -1071,7 +1071,7 @@
               ]
             },
             "then": {
-              "$ref": "#/definitions/__schema816"
+              "$ref": "#/definitions/__schema822"
             }
           }
         ]
@@ -8120,15 +8120,69 @@
       "const": "shadowsocks"
     },
     "__schema597": {
-      "oneOf": [
+      "markdownDescription": "`InboundConfigurationObject` corresponds to the `settings` item in [`InboundObject`](https://xtls.github.io/en/config/inbound.html).\n",
+      "properties": {
+        "method": {
+          "enum": [
+            "2022-blake3-aes-128-gcm",
+            "2022-blake3-aes-256-gcm",
+            "2022-blake3-chacha20-poly1305",
+            "aes-256-gcm",
+            "aes-128-gcm",
+            "chacha20-poly1305",
+            "chacha20-ietf-poly1305",
+            "xchacha20-poly1305",
+            "xchacha20-ietf-poly1305",
+            "none",
+            ""
+          ]
+        }
+      },
+      "allOf": [
         {
-          "$ref": "#/definitions/__schema598"
+          "if": {
+            "properties": {
+              "method": {
+                "enum": [
+                  "2022-blake3-aes-128-gcm",
+                  "2022-blake3-aes-256-gcm",
+                  "2022-blake3-chacha20-poly1305"
+                ]
+              }
+            },
+            "required": [
+              "method"
+            ]
+          },
+          "then": {
+            "$ref": "#/definitions/__schema598"
+          }
         },
         {
-          "$ref": "#/definitions/__schema608"
+          "if": {
+            "properties": {
+              "method": {
+                "enum": [
+                  "aes-256-gcm",
+                  "aes-128-gcm",
+                  "chacha20-poly1305",
+                  "chacha20-ietf-poly1305",
+                  "xchacha20-poly1305",
+                  "xchacha20-ietf-poly1305",
+                  "none",
+                  ""
+                ]
+              }
+            },
+            "required": [
+              "method"
+            ]
+          },
+          "then": {
+            "$ref": "#/definitions/__schema611"
+          }
         }
-      ],
-      "markdownDescription": "`InboundConfigurationObject` corresponds to the `settings` item in [`InboundObject`](https://xtls.github.io/en/config/inbound.html).\n"
+      ]
     },
     "__schema598": {
       "type": "object",
@@ -8151,17 +8205,15 @@
           "markdownDescription": "Encryption method. See the recommended and supported options in the protocol description above.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema604"
+              "$ref": "#/definitions/__schema606"
             }
           ]
         },
         "users": {
-          "markdownDescription": "An array representing a group of users recognized by the server. Each item is a [UserObject](https://xtls.github.io/en/config/inbounds/shadowsocks.html#userobject).\n\nWhen this option exists, it indicates that multi-user mode is enabled.\n",
-          "allOf": [
-            {
-              "$ref": "#/definitions/__schema605"
-            }
-          ]
+          "$ref": "#/definitions/__schema607"
+        },
+        "clients": {
+          "$ref": "#/definitions/__schema607"
         }
       },
       "required": [
@@ -8207,13 +8259,39 @@
     },
     "__schema604": {
       "type": "string",
-      "enum": [
-        "2022-blake3-aes-128-gcm",
-        "2022-blake3-aes-256-gcm",
-        "2022-blake3-chacha20-poly1305"
-      ]
+      "const": "2022-blake3-aes-128-gcm"
     },
     "__schema605": {
+      "anyOf": [
+        {
+          "type": "string",
+          "const": "2022-blake3-aes-256-gcm"
+        },
+        {
+          "type": "string",
+          "const": "2022-blake3-chacha20-poly1305"
+        }
+      ]
+    },
+    "__schema606": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/__schema604"
+        },
+        {
+          "$ref": "#/definitions/__schema605"
+        }
+      ]
+    },
+    "__schema607": {
+      "markdownDescription": "An array representing a group of users recognized by the server. Each item is a [UserObject](https://xtls.github.io/en/config/inbounds/shadowsocks.html#userobject).\n\nWhen this option exists, it indicates that multi-user mode is enabled.\n",
+      "allOf": [
+        {
+          "$ref": "#/definitions/__schema608"
+        }
+      ]
+    },
+    "__schema608": {
       "type": "array",
       "items": {
         "type": "object",
@@ -8222,7 +8300,7 @@
             "markdownDescription": "Note that SS2022 does not ignore the upper-level `password` like the old SS did. The correct password format for the client should be `ServerPassword:UserPassword`. For example: `\"password\": \"114514:1919810\"`.\n",
             "allOf": [
               {
-                "$ref": "#/definitions/__schema606"
+                "$ref": "#/definitions/__schema609"
               }
             ]
           },
@@ -8230,7 +8308,7 @@
             "markdownDescription": "Same meaning as `level` in `InboundConfigurationObject`.\n",
             "allOf": [
               {
-                "$ref": "#/definitions/__schema607"
+                "$ref": "#/definitions/__schema610"
               }
             ]
           },
@@ -8246,14 +8324,14 @@
         "additionalProperties": false
       }
     },
-    "__schema606": {
+    "__schema609": {
       "type": "string"
     },
-    "__schema607": {
+    "__schema610": {
       "default": 0,
       "type": "number"
     },
-    "__schema608": {
+    "__schema611": {
       "type": "object",
       "properties": {
         "network": {
@@ -8274,17 +8352,15 @@
           "markdownDescription": "Encryption method. See the recommended and supported options in the protocol description above.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema609"
+              "$ref": "#/definitions/__schema614"
             }
           ]
         },
         "users": {
-          "markdownDescription": "An array representing a group of users recognized by the server. Each item is a [UserObject](https://xtls.github.io/en/config/inbounds/shadowsocks.html#userobject).\n\nWhen this option exists, it indicates that multi-user mode is enabled.\n",
-          "allOf": [
-            {
-              "$ref": "#/definitions/__schema610"
-            }
-          ]
+          "$ref": "#/definitions/__schema615"
+        },
+        "clients": {
+          "$ref": "#/definitions/__schema615"
         }
       },
       "required": [
@@ -8292,20 +8368,81 @@
       ],
       "additionalProperties": false
     },
-    "__schema609": {
+    "__schema612": {
       "type": "string",
-      "enum": [
-        "aes-256-gcm",
-        "aes-128-gcm",
-        "chacha20-poly1305",
-        "chacha20-ietf-poly1305",
-        "xchacha20-poly1305",
-        "xchacha20-ietf-poly1305",
-        "none",
-        ""
+      "const": "aes-256-gcm"
+    },
+    "__schema613": {
+      "anyOf": [
+        {
+          "type": "string",
+          "const": "aes-128-gcm"
+        },
+        {
+          "anyOf": [
+            {
+              "type": "string",
+              "const": "chacha20-poly1305"
+            },
+            {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "const": "chacha20-ietf-poly1305"
+                },
+                {
+                  "anyOf": [
+                    {
+                      "type": "string",
+                      "const": "xchacha20-poly1305"
+                    },
+                    {
+                      "anyOf": [
+                        {
+                          "type": "string",
+                          "const": "xchacha20-ietf-poly1305"
+                        },
+                        {
+                          "anyOf": [
+                            {
+                              "type": "string",
+                              "const": "none"
+                            },
+                            {
+                              "type": "string",
+                              "const": ""
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
       ]
     },
-    "__schema610": {
+    "__schema614": {
+      "anyOf": [
+        {
+          "$ref": "#/definitions/__schema612"
+        },
+        {
+          "$ref": "#/definitions/__schema613"
+        }
+      ]
+    },
+    "__schema615": {
+      "markdownDescription": "An array representing a group of users recognized by the server. Each item is a [UserObject](https://xtls.github.io/en/config/inbounds/shadowsocks.html#userobject).\n\nWhen this option exists, it indicates that multi-user mode is enabled.\n",
+      "allOf": [
+        {
+          "$ref": "#/definitions/__schema616"
+        }
+      ]
+    },
+    "__schema616": {
       "type": "array",
       "items": {
         "type": "object",
@@ -8314,7 +8451,7 @@
             "markdownDescription": "Note that SS2022 does not ignore the upper-level `password` like the old SS did. The correct password format for the client should be `ServerPassword:UserPassword`. For example: `\"password\": \"114514:1919810\"`.\n",
             "allOf": [
               {
-                "$ref": "#/definitions/__schema611"
+                "$ref": "#/definitions/__schema617"
               }
             ]
           },
@@ -8322,7 +8459,7 @@
             "markdownDescription": "Same meaning as `level` in `InboundConfigurationObject`.\n",
             "allOf": [
               {
-                "$ref": "#/definitions/__schema612"
+                "$ref": "#/definitions/__schema618"
               }
             ]
           },
@@ -8335,7 +8472,7 @@
             "markdownDescription": "When the `method` in `InboundConfigurationObject` is not an SS2022 option, you can specify `method` for each user here (only non-SS2022 options are supported) together with `password`. In that case, the `password` set in `InboundConfigurationObject` will be ignored.\n\nWhen the `method` in `InboundConfigurationObject` is an SS2022 option, setting `method` for individual users is not supported; it is unified to the method specified in `InboundConfigurationObject`.\n",
             "allOf": [
               {
-                "$ref": "#/definitions/__schema609"
+                "$ref": "#/definitions/__schema614"
               }
             ]
           }
@@ -8346,14 +8483,14 @@
         "additionalProperties": false
       }
     },
-    "__schema611": {
+    "__schema617": {
       "type": "string"
     },
-    "__schema612": {
+    "__schema618": {
       "default": 0,
       "type": "number"
     },
-    "__schema613": {
+    "__schema619": {
       "type": "object",
       "properties": {
         "tag": {
@@ -8372,10 +8509,10 @@
           "$ref": "#/definitions/__schema552"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema614"
+          "$ref": "#/definitions/__schema620"
         },
         "settings": {
-          "$ref": "#/definitions/__schema615"
+          "$ref": "#/definitions/__schema621"
         }
       },
       "required": [
@@ -8385,35 +8522,35 @@
       "additionalProperties": false,
       "markdownDescription": "VLESS is a stateless, lightweight transport protocol. It is divided into inbound and outbound parts and can serve as a bridge between Xray clients and servers.\n\nUnlike [VMess](https://xtls.github.io/en/config/inbounds/vmess.html), VLESS does not depend on system time. The authentication method is also UUID.\n\n[Documentation ↗](https://xtls.github.io/en/config/inbounds/vless.html)\n"
     },
-    "__schema614": {
+    "__schema620": {
       "type": "string",
       "const": "vless"
     },
-    "__schema615": {
+    "__schema621": {
       "anyOf": [
         {
-          "$ref": "#/definitions/__schema616"
+          "$ref": "#/definitions/__schema622"
         },
         {
-          "$ref": "#/definitions/__schema633"
+          "$ref": "#/definitions/__schema639"
         }
       ],
       "markdownDescription": "`InboundConfigurationObject` corresponds to the `settings` item in [`InboundObject`](https://xtls.github.io/en/config/inbound.html).\n"
     },
-    "__schema616": {
+    "__schema622": {
       "type": "object",
       "properties": {
         "decryption": {
-          "$ref": "#/definitions/__schema617"
+          "$ref": "#/definitions/__schema623"
         },
         "fallbacks": {
-          "$ref": "#/definitions/__schema620"
+          "$ref": "#/definitions/__schema626"
         },
         "users": {
           "markdownDescription": "An array representing a group of users approved by the server. Each item is a [UserObject](https://xtls.github.io/en/config/inbounds/vless.html#userobject).\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema622"
+              "$ref": "#/definitions/__schema628"
             }
           ]
         }
@@ -8423,33 +8560,33 @@
       ],
       "additionalProperties": false
     },
-    "__schema617": {
+    "__schema623": {
       "anyOf": [
         {
-          "$ref": "#/definitions/__schema618"
+          "$ref": "#/definitions/__schema624"
         },
         {
-          "$ref": "#/definitions/__schema619"
+          "$ref": "#/definitions/__schema625"
         }
       ],
       "markdownDescription": "VLESS Encryption settings. Cannot be left empty; to disable, explicitly set it to `\"none\"`.\n\nIt is recommended for most users to use the `xray vlessenc` command to automatically generate this field to avoid configuration mistakes. The detailed configuration below is recommended for advanced users only.\n\nDetailed configuration format is a string of blocks connected by dots, for example:\n\n`mlkem768x25519plus.native.600s.100-111-1111.75-0-111.50-0-3333.ptjHQxBQxTJ9MWr2cd5qWIflBSACHOevTauCQwa_71U`\n\nThis document refers to the individual parts separated by dots as blocks.\n\n- The 1st block is the handshake method. Currently, there is only `mlkem768x25519plus`. Requires the server and client to match.\n- The 2nd block is the encryption method. Options are `native`/`xorpub`/`random`, corresponding to: raw format packets / raw format + obfuscated public key part / full random numbers (similar to VMess/Shadowsocks). Requires the server and client to match.\n- The 3rd block is the session resumption ticket validity time. Format is `600s` or `100-500s`. The former will pick a random time between that duration and half of that duration (e.g., `600s` = `300-600s`); the latter manually specifies a random range.\n\nFollowing this is padding. After the connection is established, the server sends garbage data to obfuscate length characteristics. This does not need to be the same as the client (the same part in the outbound is the padding sent from the client to the server). It is a variable-length part, formatted as `padding.delay.padding` + `(.delay.padding)*n`. Multiple paddings can be inserted, requiring a delay block between two padding blocks.\n\n- The `padding` format is `probability-min-max`, e.g., `100-111-1111` means 100% probability of sending a padding with a length of 111~1111.\n- The `delay` format is also `probability-min-max`, e.g., `75-0-111` means 75% probability of waiting for 0~111 milliseconds.\n\nThe first padding block has special requirements: it requires 100% probability and a minimum length greater than 0. If no padding exists, the core automatically uses `100-111-1111.75-0-111.50-0-3333` as the padding setting.\n\nThe last block is identified by the core as the parameter used to authenticate the client. It can be generated using `./xray x25519` (using the PrivateKey part) or `./xray mlkem768` (using the Seed part). It must correspond to the client. `mlkem768` is a post-quantum algorithm that prevents the private key from being cracked by quantum computers (in the future) to impersonate the server if client parameters are leaked. This parameter is only used for verification; the handshake process is post-quantum secure regardless, and existing encrypted data cannot be cracked by future quantum computers.\n"
     },
-    "__schema618": {
+    "__schema624": {
       "type": "string",
       "const": "none"
     },
-    "__schema619": {
+    "__schema625": {
       "type": "string"
     },
-    "__schema620": {
+    "__schema626": {
       "markdownDescription": "An array containing a series of powerful fallback distribution configurations (optional). For specific fallback configurations, see [FallbackObject](https://xtls.github.io/en/config/features/fallback.html#fallbacks-configuration).\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema621"
+          "$ref": "#/definitions/__schema627"
         }
       ]
     },
-    "__schema621": {
+    "__schema627": {
       "type": "array",
       "items": {
         "type": "object",
@@ -8484,26 +8621,26 @@
         "additionalProperties": false
       }
     },
-    "__schema622": {
+    "__schema628": {
       "default": [],
       "type": "array",
       "items": {
         "type": "object",
         "properties": {
           "id": {
-            "$ref": "#/definitions/__schema623"
+            "$ref": "#/definitions/__schema629"
           },
           "level": {
-            "$ref": "#/definitions/__schema624"
+            "$ref": "#/definitions/__schema630"
           },
           "email": {
-            "$ref": "#/definitions/__schema626"
+            "$ref": "#/definitions/__schema632"
           },
           "flow": {
-            "$ref": "#/definitions/__schema628"
+            "$ref": "#/definitions/__schema634"
           },
           "reverse": {
-            "$ref": "#/definitions/__schema630"
+            "$ref": "#/definitions/__schema636"
           }
         },
         "required": [
@@ -8512,43 +8649,43 @@
         "additionalProperties": {}
       }
     },
-    "__schema623": {
+    "__schema629": {
       "type": "string",
       "minLength": 1,
       "markdownDescription": "The user ID for VLESS. It can be any string less than 30 bytes or a valid UUID. A custom string and its mapped UUID are equivalent.\n\nMapping standard: [VLESS UUID Mapping Standard: Mapping Custom Strings to a UUIDv5](https://github.com/XTLS/Xray-core/issues/158).\n\nUse `xray uuid -i \"custom string\"` to generate the mapped UUID, or `xray uuid` to generate a random UUID.\n"
     },
-    "__schema624": {
+    "__schema630": {
       "markdownDescription": "User level. The connection will use the [Local Policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `level` corresponds to the `level` value in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, the default is 0.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema625"
+          "$ref": "#/definitions/__schema631"
         }
       ]
     },
-    "__schema625": {
+    "__schema631": {
       "default": 0,
       "type": "number"
     },
-    "__schema626": {
+    "__schema632": {
       "markdownDescription": "User email, used to distinguish traffic from different users (reflected in logs and statistics).\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema627"
+          "$ref": "#/definitions/__schema633"
         }
       ]
     },
-    "__schema627": {
+    "__schema633": {
       "type": "string"
     },
-    "__schema628": {
+    "__schema634": {
       "markdownDescription": "Flow control mode, used to select the XTLS algorithm.\n\nAvailable inbound flow control modes:\n\n- Empty string: use standard TLS proxy.\n- `xtls-rprx-vision`: use the new XTLS mode, including inner handshake random padding.\n\nXTLS is only available under the following combinations:\n\n- TCP+TLS/REALITY: In this case, if transmitting TLS 1.3, the core will attempt to Splice encrypted data at the bottom layer. If successful, it saves all core IO overhead.\n- VLESS Encryption: no underlying transport restrictions. If the underlying layer does not support direct copying (see above), it only penetrates Encryption.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema629"
+          "$ref": "#/definitions/__schema635"
         }
       ]
     },
-    "__schema629": {
+    "__schema635": {
       "default": "",
       "type": "string",
       "enum": [
@@ -8556,15 +8693,15 @@
         "xtls-rprx-vision"
       ]
     },
-    "__schema630": {
+    "__schema636": {
       "markdownDescription": "VLESS simplified reverse proxy configuration.\n\nThe presence of this item indicates that connections from this user can be used to establish a reverse proxy tunnel, while disabling normal forward proxy usage.\n\n### TIP\n\nFull tutorial: [VLESS Reverse Proxy Examples](https://xtls.github.io/en/document/level-2/vless_reverse.html)\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema631"
+          "$ref": "#/definitions/__schema637"
         }
       ]
     },
-    "__schema631": {
+    "__schema637": {
       "default": {},
       "type": "object",
       "properties": {
@@ -8572,31 +8709,31 @@
           "markdownDescription": "`tag` is the outbound proxy tag for this reverse proxy. Routing traffic to this outbound using routing rules will forward it through the reverse proxy to the connected client's routing system (see VLESS outbound for client configuration details).\n\nWhen multiple different connections (potentially from different devices) are connected, the core randomly selects one to dispatch reverse proxy data for each request.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema632"
+              "$ref": "#/definitions/__schema638"
             }
           ]
         }
       },
       "additionalProperties": false
     },
-    "__schema632": {
+    "__schema638": {
       "type": "string",
       "minLength": 1
     },
-    "__schema633": {
+    "__schema639": {
       "type": "object",
       "properties": {
         "decryption": {
-          "$ref": "#/definitions/__schema617"
+          "$ref": "#/definitions/__schema623"
         },
         "fallbacks": {
-          "$ref": "#/definitions/__schema620"
+          "$ref": "#/definitions/__schema626"
         },
         "clients": {
           "markdownDescription": "An array representing a group of users approved by the server. Each item is a [UserObject](https://xtls.github.io/en/config/inbounds/vless.html#userobject).\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema634"
+              "$ref": "#/definitions/__schema640"
             }
           ]
         }
@@ -8606,26 +8743,26 @@
       ],
       "additionalProperties": false
     },
-    "__schema634": {
+    "__schema640": {
       "default": [],
       "type": "array",
       "items": {
         "type": "object",
         "properties": {
           "id": {
-            "$ref": "#/definitions/__schema623"
+            "$ref": "#/definitions/__schema629"
           },
           "level": {
-            "$ref": "#/definitions/__schema624"
+            "$ref": "#/definitions/__schema630"
           },
           "email": {
-            "$ref": "#/definitions/__schema626"
+            "$ref": "#/definitions/__schema632"
           },
           "flow": {
-            "$ref": "#/definitions/__schema628"
+            "$ref": "#/definitions/__schema634"
           },
           "reverse": {
-            "$ref": "#/definitions/__schema630"
+            "$ref": "#/definitions/__schema636"
           }
         },
         "required": [
@@ -8634,7 +8771,7 @@
         "additionalProperties": {}
       }
     },
-    "__schema635": {
+    "__schema641": {
       "type": "object",
       "properties": {
         "tag": {
@@ -8653,10 +8790,10 @@
           "$ref": "#/definitions/__schema552"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema636"
+          "$ref": "#/definitions/__schema642"
         },
         "settings": {
-          "$ref": "#/definitions/__schema637"
+          "$ref": "#/definitions/__schema643"
         }
       },
       "required": [
@@ -8666,47 +8803,47 @@
       "additionalProperties": false,
       "markdownDescription": "[VMess](https://xtls.github.io/en/development/protocols/vmess.html) is an encrypted transport protocol, commonly acting as a bridge between the Xray client and server.\n\n### DANGER\n\nVMess depends on system time. Please ensure that the system UTC time of the device running Xray is within 120 seconds of the actual time, regardless of the time zone. On Linux systems, you can install the `ntp` service to automatically synchronize system time.\n\n[Documentation ↗](https://xtls.github.io/en/config/inbounds/vmess.html)\n"
     },
-    "__schema636": {
+    "__schema642": {
       "type": "string",
       "const": "vmess"
     },
-    "__schema637": {
+    "__schema643": {
       "anyOf": [
         {
-          "$ref": "#/definitions/__schema638"
+          "$ref": "#/definitions/__schema644"
         },
         {
-          "$ref": "#/definitions/__schema645"
+          "$ref": "#/definitions/__schema651"
         }
       ],
       "markdownDescription": "`InboundConfigurationObject` corresponds to the `settings` item in [`InboundObject`](https://xtls.github.io/en/config/inbound.html).\n"
     },
-    "__schema638": {
+    "__schema644": {
       "type": "object",
       "properties": {
         "default": {
-          "$ref": "#/definitions/__schema639"
+          "$ref": "#/definitions/__schema645"
         },
         "clients": {
           "markdownDescription": "An array representing a group of users accepted by the server. Each item is a UserObject.\n\nWhen this configuration is used for dynamic ports, Xray will automatically create users.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema641"
+              "$ref": "#/definitions/__schema647"
             }
           ]
         }
       },
       "additionalProperties": false
     },
-    "__schema639": {
+    "__schema645": {
       "markdownDescription": "Optional. Default configuration for `users`. Only valid when used in conjunction with `detour`.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema640"
+          "$ref": "#/definitions/__schema646"
         }
       ]
     },
-    "__schema640": {
+    "__schema646": {
       "type": "object",
       "properties": {
         "level": {
@@ -8719,14 +8856,14 @@
       ],
       "additionalProperties": false
     },
-    "__schema641": {
+    "__schema647": {
       "default": [],
       "type": "array",
       "items": {
-        "$ref": "#/definitions/__schema642"
+        "$ref": "#/definitions/__schema648"
       }
     },
-    "__schema642": {
+    "__schema648": {
       "type": "object",
       "properties": {
         "id": {
@@ -8738,7 +8875,7 @@
           "markdownDescription": "User level. The connection will use the [Local Policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `level` corresponds to the value of `level` in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, it defaults to 0.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema643"
+              "$ref": "#/definitions/__schema649"
             }
           ]
         },
@@ -8746,7 +8883,7 @@
           "markdownDescription": "User email address, used to distinguish traffic from different users.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema644"
+              "$ref": "#/definitions/__schema650"
             }
           ]
         }
@@ -8756,37 +8893,37 @@
       ],
       "additionalProperties": false
     },
-    "__schema643": {
+    "__schema649": {
       "type": "number"
     },
-    "__schema644": {
+    "__schema650": {
       "type": "string"
     },
-    "__schema645": {
+    "__schema651": {
       "type": "object",
       "properties": {
         "default": {
-          "$ref": "#/definitions/__schema639"
+          "$ref": "#/definitions/__schema645"
         },
         "users": {
           "markdownDescription": "An array representing a group of users accepted by the server. Each item is a UserObject.\n\nWhen this configuration is used for dynamic ports, Xray will automatically create users.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema646"
+              "$ref": "#/definitions/__schema652"
             }
           ]
         }
       },
       "additionalProperties": false
     },
-    "__schema646": {
+    "__schema652": {
       "default": [],
       "type": "array",
       "items": {
-        "$ref": "#/definitions/__schema642"
+        "$ref": "#/definitions/__schema648"
       }
     },
-    "__schema647": {
+    "__schema653": {
       "type": "object",
       "properties": {
         "tag": {
@@ -8805,10 +8942,10 @@
           "$ref": "#/definitions/__schema552"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema648"
+          "$ref": "#/definitions/__schema654"
         },
         "settings": {
-          "$ref": "#/definitions/__schema649"
+          "$ref": "#/definitions/__schema655"
         }
       },
       "required": [
@@ -8818,21 +8955,21 @@
       "additionalProperties": false,
       "markdownDescription": "User-space WireGuard protocol implementation.\n\n### DANGER\n\n**The WireGuard protocol is not designed specifically for bypassing firewalls. If used as the outer layer to cross the firewall, its distinct characteristics may lead to the server being blocked.**\n\n[Documentation ↗](https://xtls.github.io/en/config/inbounds/wireguard.html)\n"
     },
-    "__schema648": {
+    "__schema654": {
       "type": "string",
       "const": "wireguard"
     },
-    "__schema649": {
+    "__schema655": {
       "type": "object",
       "properties": {
         "secretKey": {
-          "$ref": "#/definitions/__schema650"
+          "$ref": "#/definitions/__schema656"
         },
         "peers": {
-          "$ref": "#/definitions/__schema651"
+          "$ref": "#/definitions/__schema657"
         },
         "mtu": {
-          "$ref": "#/definitions/__schema654"
+          "$ref": "#/definitions/__schema660"
         }
       },
       "required": [
@@ -8841,19 +8978,19 @@
       "additionalProperties": false,
       "markdownDescription": "`InboundConfigurationObject` corresponds to the `settings` item in [`InboundObject`](https://xtls.github.io/en/config/inbound.html).\n"
     },
-    "__schema650": {
+    "__schema656": {
       "type": "string",
       "markdownDescription": "Private key. Required.\n"
     },
-    "__schema651": {
+    "__schema657": {
       "markdownDescription": "List of peers, where each item is a peer configuration.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema652"
+          "$ref": "#/definitions/__schema658"
         }
       ]
     },
-    "__schema652": {
+    "__schema658": {
       "default": [],
       "type": "array",
       "items": {
@@ -8867,7 +9004,7 @@
           "allowedIPs": {
             "type": "array",
             "items": {
-              "$ref": "#/definitions/__schema653"
+              "$ref": "#/definitions/__schema659"
             },
             "markdownDescription": "Allowed source IPs.\n"
           }
@@ -8879,23 +9016,23 @@
         "additionalProperties": false
       }
     },
-    "__schema653": {
+    "__schema659": {
       "type": "string",
       "minLength": 1
     },
-    "__schema654": {
+    "__schema660": {
       "markdownDescription": "The MTU size of the underlying WireGuard TUN.\n\nMethod to Calculate MTU\n\n- 20-byte IPv4 header or 40 byte IPv6 header\n- 8-byte UDP header\n- 4-byte type\n- 4-byte key index\n- 8-byte nonce\n- N-byte encrypted data\n- 16-byte authentication tag\n\n`N-byte encrypted data` is the MTU value needed. Depending on whether the endpoint is IPv4 or IPv6, the specific value can be 1440 (IPv4) or 1420 (IPv6). If you are in a special network environment, you may need to subtract more (e.g., home broadband PPPoE requires an extra -8).\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema655"
+          "$ref": "#/definitions/__schema661"
         }
       ]
     },
-    "__schema655": {
+    "__schema661": {
       "default": 1420,
       "type": "number"
     },
-    "__schema656": {
+    "__schema662": {
       "type": "object",
       "properties": {
         "tag": {
@@ -8914,10 +9051,10 @@
           "$ref": "#/definitions/__schema552"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema657"
+          "$ref": "#/definitions/__schema663"
         },
         "settings": {
-          "$ref": "#/definitions/__schema658"
+          "$ref": "#/definitions/__schema664"
         }
       },
       "required": [
@@ -8927,32 +9064,32 @@
       "additionalProperties": false,
       "markdownDescription": "[Trojan](https://trojan-gfw.github.io/trojan/protocol) protocol.\n\n### DANGER\n\nTrojan is designed to work over correctly configured encrypted TLS tunnels.\n\n[Documentation ↗](https://xtls.github.io/en/config/inbounds/trojan.html)\n"
     },
-    "__schema657": {
+    "__schema663": {
       "type": "string",
       "const": "trojan"
     },
-    "__schema658": {
+    "__schema664": {
       "type": "object",
       "properties": {
         "users": {
-          "$ref": "#/definitions/__schema659"
+          "$ref": "#/definitions/__schema665"
         },
         "fallbacks": {
-          "$ref": "#/definitions/__schema662"
+          "$ref": "#/definitions/__schema668"
         }
       },
       "additionalProperties": false,
       "markdownDescription": "`InboundConfigurationObject` corresponds to the `settings` item in [`InboundObject`](https://xtls.github.io/en/config/inbound.html).\n"
     },
-    "__schema659": {
+    "__schema665": {
       "markdownDescription": "An array representing a group of users accepted by the server. Each item is a [UserObjects](https://xtls.github.io/en/config/inbounds/trojan.html#userobject).\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema660"
+          "$ref": "#/definitions/__schema666"
         }
       ]
     },
-    "__schema660": {
+    "__schema666": {
       "default": [],
       "type": "array",
       "items": {
@@ -8972,7 +9109,7 @@
             "markdownDescription": "User level. Connections will use the [Local Policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `userLevel` corresponds to the value of `level` in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, it defaults to 0.\n",
             "allOf": [
               {
-                "$ref": "#/definitions/__schema661"
+                "$ref": "#/definitions/__schema667"
               }
             ]
           }
@@ -8984,21 +9121,21 @@
         "additionalProperties": false
       }
     },
-    "__schema661": {
+    "__schema667": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema662": {
+    "__schema668": {
       "markdownDescription": "An array containing a series of powerful fallback configurations (optional). For specific configuration of fallbacks, see [FallbackObject](https://xtls.github.io/en/config/features/fallback.html#fallbackobject).\n\n### TIP\n\nXray's Trojan has complete support for fallbacks, and the configuration method is exactly the same as VLESS. The conditions for triggering fallback are also similar to VLESS: the length of the first packet < 58, OR the 57th byte is not `\\r` (because Trojan has no protocol version), OR authentication fails.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema663"
+          "$ref": "#/definitions/__schema669"
         }
       ]
     },
-    "__schema663": {
+    "__schema669": {
       "type": "array",
       "items": {
         "type": "object",
@@ -9033,7 +9170,7 @@
         "additionalProperties": false
       }
     },
-    "__schema664": {
+    "__schema670": {
       "type": "object",
       "properties": {
         "tag": {
@@ -9052,10 +9189,10 @@
           "$ref": "#/definitions/__schema552"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema665"
+          "$ref": "#/definitions/__schema671"
         },
         "settings": {
-          "$ref": "#/definitions/__schema666"
+          "$ref": "#/definitions/__schema672"
         }
       },
       "required": [
@@ -9065,33 +9202,33 @@
       "additionalProperties": false,
       "markdownDescription": "Creates a TUN interface; traffic sent to this interface will be processed by Xray. Currently, Windows, Linux, macOS, and FreeBSD are supported.\n\nOn Android, the TUN FD must be passed in from an external app, which uses VPN Service to redirect traffic. It cannot run standalone and only serves as a way for an app to feed traffic into Xray.\n\n[Documentation ↗](https://xtls.github.io/en/config/inbounds/tun.html)\n\n\n\n## Usage Tips\n\nIf `autoSystemRoutingTable` is not configured, you still need to add routes manually to direct traffic to the created TUN interface; otherwise, it remains just an interface.\n\nWhen `gateway`, `dns`, `autoSystemRoutingTable`, and `autoOutboundsInterface` are configured, Xray can perform part of the system-side setup automatically on supported platforms. If your platform does not implement these automatic settings yet, or if you need more fine-grained policy routing, you still need to configure the OS manually.\n\nIf you only want to proxy specific process(es), the process name routing in the Xray routing system will be very useful.\n\n### WARNING\n\nBe aware of potential traffic loop issues. After setting routes, requests initiated by Xray might be sent back to Xray, causing a loop. Prefer `autoOutboundsInterface` to avoid this problem. If you need manual control, you can still use `interface` in `sockopt` to bind to the actual physical network interface. `ipconfig` (Windows) or `ip a` (Linux) will help you find the interface name you need. Alternatively, use the outbound `sendThrough` setting. It is available directly in `OutboundObject` without the deep nesting level of `sockOpt.interface`. Here you need to use the IP address on the network card, such as 192.168.1.2 (As you can see, its disadvantage is that it cannot automatically support dual-stack; please choose according to the IP actually used for your outbound connection).\n"
     },
-    "__schema665": {
+    "__schema671": {
       "type": "string",
       "const": "tun"
     },
-    "__schema666": {
+    "__schema672": {
       "type": "object",
       "properties": {
         "name": {
-          "$ref": "#/definitions/__schema667"
+          "$ref": "#/definitions/__schema673"
         },
         "mtu": {
-          "$ref": "#/definitions/__schema669"
+          "$ref": "#/definitions/__schema675"
         },
         "userLevel": {
-          "$ref": "#/definitions/__schema671"
+          "$ref": "#/definitions/__schema677"
         },
         "gateway": {
-          "$ref": "#/definitions/__schema673"
+          "$ref": "#/definitions/__schema679"
         },
         "dns": {
-          "$ref": "#/definitions/__schema675"
+          "$ref": "#/definitions/__schema681"
         },
         "autoSystemRoutingTable": {
-          "$ref": "#/definitions/__schema677"
+          "$ref": "#/definitions/__schema683"
         },
         "autoOutboundsInterface": {
-          "$ref": "#/definitions/__schema679"
+          "$ref": "#/definitions/__schema685"
         }
       },
       "required": [
@@ -9101,57 +9238,57 @@
       "additionalProperties": false,
       "markdownDescription": "`InboundConfigurationObject` corresponds to the `settings` item in [`InboundObject`](https://xtls.github.io/en/config/inbound.html).\n"
     },
-    "__schema667": {
+    "__schema673": {
       "markdownDescription": "The name of the created TUN interface. Default is `\"xray0\"`.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema668"
+          "$ref": "#/definitions/__schema674"
         }
       ]
     },
-    "__schema668": {
+    "__schema674": {
       "default": "xray0",
       "type": "string"
     },
-    "__schema669": {
+    "__schema675": {
       "markdownDescription": "The MTU of the interface. The default is `1500`.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema670"
+          "$ref": "#/definitions/__schema676"
         }
       ]
     },
-    "__schema670": {
+    "__schema676": {
       "default": 1500,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema671": {
+    "__schema677": {
       "markdownDescription": "User level. The connection will use the [Local Policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `userLevel` corresponds to the value of `level` in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, the default is 0.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema672"
+          "$ref": "#/definitions/__schema678"
         }
       ]
     },
-    "__schema672": {
+    "__schema678": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema673": {
+    "__schema679": {
       "type": "array",
       "items": {
-        "$ref": "#/definitions/__schema674"
+        "$ref": "#/definitions/__schema680"
       },
       "markdownDescription": "The list of address prefixes assigned to the TUN interface, usually one for IPv4 and one for IPv6, such as `\"10.0.0.1/16\"` and `\"fc00::1/64\"`.\n"
     },
-    "__schema674": {
+    "__schema680": {
       "type": "string"
     },
-    "__schema675": {
+    "__schema681": {
       "default": [
         "1.1.1.1",
         "8.8.8.8"
@@ -9159,39 +9296,39 @@
       "markdownDescription": "The list of DNS servers assigned to the TUN interface, such as `\"1.1.1.1\"` and `\"8.8.8.8\"`.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema676"
+          "$ref": "#/definitions/__schema682"
         }
       ]
     },
-    "__schema676": {
+    "__schema682": {
       "type": "array",
       "items": {
         "type": "string"
       }
     },
-    "__schema677": {
+    "__schema683": {
       "markdownDescription": "The list of destination prefixes that Xray should add to the system routing table automatically so that the traffic is directed into this TUN interface. Each item is a CIDR. For example, `\"0.0.0.0/0\"` means all IPv4 traffic, and `\"::/0\"` means all IPv6 traffic.\n\nCurrently only supported on Windows. On other systems, the routing table must be configured manually.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema678"
+          "$ref": "#/definitions/__schema684"
         }
       ]
     },
-    "__schema678": {
+    "__schema684": {
       "type": "array",
       "items": {
         "type": "string"
       }
     },
-    "__schema679": {
+    "__schema685": {
       "markdownDescription": "Automatically binds Xray outbounds to a physical network interface, so that traffic generated by Xray itself is not sent back into the TUN interface and looped.\n\nThe default value is `null`, which means not configured. You can specify an interface name explicitly, or use `\"auto\"` to let Xray choose one automatically. If `autoSystemRoutingTable` is configured but this field is omitted, Xray treats it as `\"auto\"`.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema680"
+          "$ref": "#/definitions/__schema686"
         }
       ]
     },
-    "__schema680": {
+    "__schema686": {
       "default": null,
       "anyOf": [
         {
@@ -9210,7 +9347,7 @@
         }
       ]
     },
-    "__schema681": {
+    "__schema687": {
       "type": "object",
       "properties": {
         "tag": {
@@ -9229,10 +9366,10 @@
           "$ref": "#/definitions/__schema552"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema682"
+          "$ref": "#/definitions/__schema688"
         },
         "settings": {
-          "$ref": "#/definitions/__schema683"
+          "$ref": "#/definitions/__schema689"
         }
       },
       "required": [
@@ -9242,18 +9379,18 @@
       "additionalProperties": false,
       "markdownDescription": "### TIP\n\nThe `hysteria` protocol itself has no authentication; `users` only take effect when used with the `hysteria` transport layer.\n\n[Documentation ↗](https://xtls.github.io/en/config/inbounds/hysteria.html)\n"
     },
-    "__schema682": {
+    "__schema688": {
       "type": "string",
       "const": "hysteria"
     },
-    "__schema683": {
+    "__schema689": {
       "type": "object",
       "properties": {
         "version": {
-          "$ref": "#/definitions/__schema684"
+          "$ref": "#/definitions/__schema690"
         },
         "users": {
-          "$ref": "#/definitions/__schema685"
+          "$ref": "#/definitions/__schema691"
         }
       },
       "required": [
@@ -9262,20 +9399,20 @@
       "additionalProperties": false,
       "markdownDescription": "`InboundConfigurationObject` corresponds to the `settings` item in [`InboundObject`](https://xtls.github.io/en/config/inbound.html).\n"
     },
-    "__schema684": {
+    "__schema690": {
       "type": "number",
       "const": 2,
       "markdownDescription": "Hysteria version, must be 2.\n"
     },
-    "__schema685": {
+    "__schema691": {
       "markdownDescription": "An array representing a group of users approved by the server.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema686"
+          "$ref": "#/definitions/__schema692"
         }
       ]
     },
-    "__schema686": {
+    "__schema692": {
       "default": [],
       "type": "array",
       "items": {
@@ -9295,7 +9432,7 @@
             "markdownDescription": "User level. The connection will use the [Local Policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `level` corresponds to the value of `level` in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, the default is 0.\n",
             "allOf": [
               {
-                "$ref": "#/definitions/__schema687"
+                "$ref": "#/definitions/__schema693"
               }
             ]
           }
@@ -9307,38 +9444,38 @@
         "additionalProperties": false
       }
     },
-    "__schema687": {
+    "__schema693": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema688": {
+    "__schema694": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema705"
+          "$ref": "#/definitions/__schema711"
         },
         "settings": {
-          "$ref": "#/definitions/__schema706"
+          "$ref": "#/definitions/__schema712"
         }
       },
       "required": [
@@ -9347,15 +9484,15 @@
       "additionalProperties": false,
       "markdownDescription": "Blackhole is an outbound data protocol that blocks all outbound data. When used in conjunction with [Routing Configuration](https://xtls.github.io/en/config/routing.html), it can achieve the effect of blocking access to certain websites.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/blackhole.html)\n"
     },
-    "__schema689": {
+    "__schema695": {
       "markdownDescription": "The IP address used to send data. This is effective when the host has multiple IP addresses. The default value is `\"0.0.0.0\"`.\n\nYou can enter an IPv6 CIDR block (e.g., `114:514:1919:810::/64`), and Xray will use a random IP address from the address block to initiate external connections. You need to correctly configure the network access method, routing table, and kernel parameters to allow Xray to bind to any IP within the address block.\n\nFor networks using NDP access, it is not recommended to set a subnet smaller than `/120`. Otherwise, it may cause issues such as NDP flooding, leading to the router's neighbor cache becoming full.\n\nSpecial value `origin`: If this value is used, the request will be sent using the IP address of the local machine that received the connection.\n\nSpecial value `srcip`: If this value is used, the request will be sent using the source IP address of the inbound connection.\n\nFor example, if the machine has a full IPv4 range `11.4.5.0/24` and listens on `0.0.0.0` (all IPv4 and IPv6 on the network interface), if a client connects to the local machine via `11.4.5.14`, the outbound request will also be sent via `11.4.5.14`. If the client connects via `11.4.5.10`, the outbound request will also be sent via `11.4.5.10`. This also applies to cases where the machine has a full range/multiple IPv6 addresses.\n\nAs mentioned in the inbound introduction, because of the connectionless nature of UDP, Xray cannot know the original destination IP where the request entered the core (for example, in the same QUIC connection, it might even change), so this feature cannot take effect for UDP.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema690"
+          "$ref": "#/definitions/__schema696"
         }
       ]
     },
-    "__schema690": {
+    "__schema696": {
       "anyOf": [
         {
           "type": "string"
@@ -9369,18 +9506,18 @@
         }
       ]
     },
-    "__schema691": {
+    "__schema697": {
       "markdownDescription": "The identifier for this outbound connection, used to locate this connection in other configurations.\n\n### DANGER\n\nWhen not empty, its value must be **unique** among all `tag`s.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema692"
+          "$ref": "#/definitions/__schema698"
         }
       ]
     },
-    "__schema692": {
+    "__schema698": {
       "type": "string"
     },
-    "__schema693": {
+    "__schema699": {
       "markdownDescription": "Transport configuration for this outbound.\n",
       "allOf": [
         {
@@ -9388,15 +9525,15 @@
         }
       ]
     },
-    "__schema694": {
+    "__schema700": {
       "markdownDescription": "If this outbound attempts to send a domain request, this controls whether it is resolved/how it is resolved to an IP before sending.\n\nThe default value is `AsIs`, meaning it is sent to the remote server as is. All parameter meanings are roughly equivalent to `domainStrategy` in [Sockopt](https://xtls.github.io/en/config/transports/sockopt.html#sockoptobject).\n\n### TIP\n\nThis controls **proxied requests**. If the address of the outbound proxy server is a domain name, and you need to select a resolution strategy for the domain name itself, you should configure `domainStrategy` in [Sockopt](https://xtls.github.io/en/config/transports/sockopt.html#sockoptobject).\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema695"
+          "$ref": "#/definitions/__schema701"
         }
       ]
     },
-    "__schema695": {
+    "__schema701": {
       "default": "AsIs",
       "type": "string",
       "enum": [
@@ -9413,15 +9550,15 @@
         "ForceIPv4"
       ]
     },
-    "__schema696": {
+    "__schema702": {
       "markdownDescription": "Outbound proxy configuration.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema697"
+          "$ref": "#/definitions/__schema703"
         }
       ]
     },
-    "__schema697": {
+    "__schema703": {
       "type": "object",
       "properties": {
         "tag": {
@@ -9433,7 +9570,7 @@
           "markdownDescription": "`true` converts this setting to `Sockopt.dialerProxy` so the forwarding can use this outbound's `streamSettings`. The default is `false`.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema698"
+              "$ref": "#/definitions/__schema704"
             }
           ]
         }
@@ -9443,26 +9580,26 @@
       ],
       "additionalProperties": false
     },
-    "__schema698": {
+    "__schema704": {
       "default": false,
       "type": "boolean"
     },
-    "__schema699": {
+    "__schema705": {
       "markdownDescription": "The Mux function distributes data from multiple TCP connections over a single TCP connection. For implementation details, see [Mux.Cool](https://xtls.github.io/en/development/protocols/muxcool.html). Mux is designed to reduce TCP handshake latency, not to increase connection throughput. Using Mux for watching videos, downloading, or speed testing usually has a negative effect. Mux only needs to be enabled on the client side; the server side adapts automatically. The second use of Mux is to distribute multiple UDP connections, i.e., XUDP.\n\n`MuxObject` corresponds to the `mux` item in `OutboundObject`.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema700"
+          "$ref": "#/definitions/__schema706"
         }
       ]
     },
-    "__schema700": {
+    "__schema706": {
       "type": "object",
       "properties": {
         "enabled": {
           "markdownDescription": "Whether to enable Mux for forwarding requests. Default is `false`.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema701"
+              "$ref": "#/definitions/__schema707"
             }
           ]
         },
@@ -9470,7 +9607,7 @@
           "markdownDescription": "Maximum concurrent connections. Minimum `1`, maximum `128`. If omitted or set to `0`, it equals `8`. Values greater than `128` are treated as 128, because once a connection reaches the maximum reuse count of 128, it will no longer be assigned any new sub-connections.\n\nThis value represents the maximum number of sub-connections carried on a single TCP connection. For example, if `concurrency=8` is set, when the client issues 8 TCP requests, Xray will only issue one actual TCP connection, and all 8 requests from the client are transmitted over this TCP connection.\n\nWhen the maximum sub-connection capacity of all Mux connections is fully occupied, the core will initiate new connections to carry sub-connections. If a large number of sub-connections are concurrent in a short time and subsequently decrease, the internal scheduler of the core will tend to distribute requests to 2 connections alternately and leave other connections idle, waiting for all their sub-connections to end naturally before closing them to save resources. If the total number of sub-connections continues to be lower than `concurrency` for a long time, after one of the connections reaches the maximum reuse count, the core will revert to a single connection state.\n\n### TIP\n\nWhen set to a negative number, such as `-1`, the Mux module is not used to carry TCP traffic.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema702"
+              "$ref": "#/definitions/__schema708"
             }
           ]
         },
@@ -9478,7 +9615,7 @@
           "markdownDescription": "Use a new XUDP aggregation tunnel (i.e., another Mux connection) to proxy UDP traffic. Fill in the maximum number of concurrent sub-UoT. Minimum `1`, maximum `1024`. If omitted or set to `0`, it will follow the same path as TCP traffic, which is the traditional behavior.\n\n### TIP\n\nWhen set to a negative number, such as `-1`, the Mux module is not used to carry UDP traffic. The proxy protocol's original UDP transmission method will be used. For example, `Shadowsocks` will use native UDP, and `VLESS` will use UoT.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema703"
+              "$ref": "#/definitions/__schema709"
             }
           ]
         },
@@ -9486,28 +9623,28 @@
           "markdownDescription": "Controls how Mux handles proxied UDP/443 (QUIC) traffic:\n\n- Default `reject`: Rejects traffic (browsers typically fall back to TCP HTTP2 automatically).\n- `allow`: Allows traffic to go through the Mux connection.\n- `skip`: Does not use the Mux module to carry UDP 443 traffic. The proxy protocol's original UDP transmission method will be used. For example, `Shadowsocks` will use native UDP, and `VLESS` will use UoT.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema704"
+              "$ref": "#/definitions/__schema710"
             }
           ]
         }
       },
       "additionalProperties": false
     },
-    "__schema701": {
+    "__schema707": {
       "default": false,
       "type": "boolean"
     },
-    "__schema702": {
+    "__schema708": {
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema703": {
+    "__schema709": {
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema704": {
+    "__schema710": {
       "default": "reject",
       "type": "string",
       "enum": [
@@ -9516,7 +9653,7 @@
         "skip"
       ]
     },
-    "__schema705": {
+    "__schema711": {
       "anyOf": [
         {
           "type": "string",
@@ -9528,43 +9665,43 @@
         }
       ]
     },
-    "__schema706": {
+    "__schema712": {
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema707"
+          "$ref": "#/definitions/__schema713"
         }
       ]
     },
-    "__schema707": {
+    "__schema713": {
       "type": "object",
       "properties": {
         "response": {
           "markdownDescription": "Configures the response data of the Blackhole.\n\nAfter receiving data to be forwarded, Blackhole will send the specified response data, then close the connection. The data to be forwarded will be discarded. If this item is not specified, Blackhole will close the connection immediately.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema708"
+              "$ref": "#/definitions/__schema714"
             }
           ]
         }
       },
       "additionalProperties": false
     },
-    "__schema708": {
+    "__schema714": {
       "type": "object",
       "properties": {
         "type": {
           "markdownDescription": "When `type` is `\"none\"` (default value), Blackhole will close the connection immediately.\n\nWhen `type` is `\"http\"`, Blackhole will send back a simple HTTP 403 response packet, then close the connection.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema709"
+              "$ref": "#/definitions/__schema715"
             }
           ]
         }
       },
       "additionalProperties": false
     },
-    "__schema709": {
+    "__schema715": {
       "default": "none",
       "type": "string",
       "enum": [
@@ -9572,32 +9709,32 @@
         "http"
       ]
     },
-    "__schema710": {
+    "__schema716": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema711"
+          "$ref": "#/definitions/__schema717"
         },
         "settings": {
-          "$ref": "#/definitions/__schema712"
+          "$ref": "#/definitions/__schema718"
         }
       },
       "required": [
@@ -9606,7 +9743,7 @@
       "additionalProperties": false,
       "markdownDescription": "Freedom is an outbound protocol used to send (normal) TCP or UDP data to any network.\n\n### WARNING\n\nThis outbound has a default safety policy in server-side and reverse-proxy scenarios, which may block some targets. See `finalRules` below for how to allow them.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/freedom.html)\n"
     },
-    "__schema711": {
+    "__schema717": {
       "anyOf": [
         {
           "type": "string",
@@ -9618,22 +9755,22 @@
         }
       ]
     },
-    "__schema712": {
+    "__schema718": {
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema713"
+          "$ref": "#/definitions/__schema719"
         }
       ]
     },
-    "__schema713": {
+    "__schema719": {
       "type": "object",
       "properties": {
         "domainStrategy": {
           "markdownDescription": "Default value `\"AsIs\"`.\n\nThe meanings of all parameters are roughly equivalent to `domainStrategy` in [Sockopt](https://xtls.github.io/en/config/transports/sockopt.html#sockoptobject).\n\nOnly using `\"AsIs\"` here allows passing the domain name to the subsequent `sockopt` module. If set to non-`\"AsIs\"` here, causing the domain to be resolved to a specific IP, it will invalidate the subsequent `sockopt.domainStrategy` and its related `happyEyeballs`. (There is no negative impact if these two settings are not adjusted).\n\nWhen sending UDP, Freedom ignores `domainStrategy` in `sockopt` for some reasons and forcibly prefers IPv4 by default.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema714"
+              "$ref": "#/definitions/__schema720"
             }
           ]
         },
@@ -9641,7 +9778,7 @@
           "markdownDescription": "Freedom will forcibly send all data to the specified address (instead of the address specified by the inbound).\n\nThe value is a string, e.g., `\"127.0.0.1:80\"`, `\":1234\"`.\n\nWhen the address is not specified, e.g., `\":443\"`, Freedom will not modify the original destination address. When the port is `0`, e.g., `\"xray.com:0\"`, Freedom will not modify the original port.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema715"
+              "$ref": "#/definitions/__schema721"
             }
           ]
         },
@@ -9649,7 +9786,7 @@
           "markdownDescription": "User level. Connections will use the [Local Policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `userLevel` corresponds to the value of `level` in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, it defaults to 0.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema716"
+              "$ref": "#/definitions/__schema722"
             }
           ]
         },
@@ -9657,13 +9794,13 @@
           "type": "object",
           "properties": {
             "length": {
-              "$ref": "#/definitions/__schema717"
+              "$ref": "#/definitions/__schema723"
             },
             "interval": {
-              "$ref": "#/definitions/__schema718"
+              "$ref": "#/definitions/__schema724"
             },
             "packets": {
-              "$ref": "#/definitions/__schema719"
+              "$ref": "#/definitions/__schema725"
             }
           },
           "required": [
@@ -9678,7 +9815,7 @@
           "markdownDescription": "UDP noise, used to send some random data as \"noise\" before sending a UDP connection. Presence of this structure implies enablement. It might deceive sniffers, or it might disrupt normal connections. _Use at your own risk._ For this reason, it bypasses port 53 because that breaks DNS.\n\nIt is an array where multiple noise packets to be sent can be defined. A single element in the array is defined as follows:\n\n`\"type\"`: Noise packet type. Currently supports `\"rand\"` (random data), `\"str\"` (user-defined string), `\"base64\"` (base64 encoded custom binary data).\n\n`\"packet\"`: The content of the packet to be sent based on the preceding `type`.\n\n- When `type` is `rand`, this specifies the length of the random data. It can be a fixed value `\"100\"` or a floating range `\"50-150\"`.\n- When `type` is `str`, this specifies the string to be sent.\n- When `type` is `hex`, this specifies binary data in hex format.\n- When `type` is `base64`, this specifies base64 encoded binary data.\n\n`\"delay\"`: Delay in milliseconds. After sending this noise packet, the core will wait for this time before sending the next noise packet or real data. Defaults to no wait. It is an [Int32Range](https://xtls.github.io/en/development/intro/guide.html#int32range) type.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema720"
+              "$ref": "#/definitions/__schema726"
             }
           ]
         },
@@ -9686,7 +9823,7 @@
           "markdownDescription": "PROXY protocol is usually used with `redirect` to redirect traffic to Nginx or other backend services that have the PROXY protocol enabled. If the backend service does not support PROXY protocol, the connection will be disconnected.\n\nThe value of `proxyProtocol` is the PROXY protocol version number. Options are `1` or `2`. If not specified, it defaults to `0` (disabled).\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema721"
+              "$ref": "#/definitions/__schema727"
             }
           ]
         },
@@ -9694,14 +9831,14 @@
           "markdownDescription": "Matches Freedom final outbound rules in order, and allows or blocks connection targets.\n\nCompared with blocking in `routing`, `finalRules` applies at Freedom's final outbound stage: matching happens after the final IP is resolved and before dialing; in addition, UDP is also matched packet by packet during send and receive, making it stricter and more thorough. Each rule match takes about 50-150 ns.\n\nNote: whenever Freedom needs to apply `finalRules`, if `domainStrategy` is `AsIs` and the target is a domain, Freedom still resolves the target to an IP through the operating system DNS before matching rules. At that point the target is no longer a domain, so the later `sockopt.domainStrategy` and its `happyEyeballs` no longer take effect.\n\n### WARNING\n\nThere is a default fallback safety policy for server-side and reverse-proxy scenarios:\n\nIf no explicit rule matches, the built-in fallback rule is used: traffic from the VLESS reverse proxy blocks all targets by default; traffic from `VLESS`, `VMess`, `Trojan`, `Shadowsocks`, `Hysteria`, or `WireGuard` inbounds blocks private and reserved IP ranges by default; other traffic is fully allowed by default.\n\nIf the server needs to allow clients to access some internal services, explicitly configure `allow` rules and limit them to the necessary `network`, `ip`, and `port` whenever possible.\n\nIf the server also needs features that rely on passing the domain to `sockopt` (such as `sockopt.domainStrategy` or `happyEyeballs`), it cannot continue relying on this default safety policy. You can configure the first rule as an `allow` rule without any matching conditions to restore the previous behavior; this is also equivalent to disabling this default safety policy, so evaluate the security impact yourself.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema722"
+              "$ref": "#/definitions/__schema728"
             }
           ]
         }
       },
       "additionalProperties": false
     },
-    "__schema714": {
+    "__schema720": {
       "default": "AsIs",
       "type": "string",
       "enum": [
@@ -9718,16 +9855,16 @@
         "ForceIPv4"
       ]
     },
-    "__schema715": {
+    "__schema721": {
       "type": "string"
     },
-    "__schema716": {
+    "__schema722": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema717": {
+    "__schema723": {
       "anyOf": [
         {
           "type": "integer",
@@ -9739,7 +9876,7 @@
         }
       ]
     },
-    "__schema718": {
+    "__schema724": {
       "anyOf": [
         {
           "type": "integer",
@@ -9751,7 +9888,7 @@
         }
       ]
     },
-    "__schema719": {
+    "__schema725": {
       "anyOf": [
         {
           "type": "string",
@@ -9762,7 +9899,7 @@
         }
       ]
     },
-    "__schema720": {
+    "__schema726": {
       "type": "array",
       "items": {
         "type": "object",
@@ -9798,7 +9935,7 @@
         "additionalProperties": false
       }
     },
-    "__schema721": {
+    "__schema727": {
       "default": 0,
       "anyOf": [
         {
@@ -9819,26 +9956,26 @@
         }
       ]
     },
-    "__schema722": {
+    "__schema728": {
       "default": [],
       "type": "array",
       "items": {
         "type": "object",
         "properties": {
           "action": {
-            "$ref": "#/definitions/__schema723"
+            "$ref": "#/definitions/__schema729"
           },
           "network": {
-            "$ref": "#/definitions/__schema724"
+            "$ref": "#/definitions/__schema730"
           },
           "port": {
-            "$ref": "#/definitions/__schema725"
+            "$ref": "#/definitions/__schema731"
           },
           "ip": {
-            "$ref": "#/definitions/__schema726"
+            "$ref": "#/definitions/__schema732"
           },
           "blockDelay": {
-            "$ref": "#/definitions/__schema728"
+            "$ref": "#/definitions/__schema734"
           }
         },
         "required": [
@@ -9850,7 +9987,7 @@
         "markdownDescription": "All matching conditions in a rule are combined with AND logic. If a condition is omitted, that condition is not restricted.\n"
       }
     },
-    "__schema723": {
+    "__schema729": {
       "type": "string",
       "enum": [
         "allow",
@@ -9858,7 +9995,7 @@
       ],
       "markdownDescription": "Defines the action to take when the rule matches.\n\n- `allow`: Allows the target.\n- `block`: Blocks the target.\n"
     },
-    "__schema724": {
+    "__schema730": {
       "type": "string",
       "enum": [
         "tcp",
@@ -9867,7 +10004,7 @@
       ],
       "markdownDescription": "Matches the network type. The rule takes effect when the connection method matches. It can also be written as a string array, such as `[\"tcp\", \"udp\"]`. If omitted, all networks are matched.\n"
     },
-    "__schema725": {
+    "__schema731": {
       "markdownDescription": "Target port range. The syntax is the same as [`port` in routing rules](https://xtls.github.io/en/config/routing.html#ruleobject). If omitted, all ports are matched.\n",
       "allOf": [
         {
@@ -9875,57 +10012,57 @@
         }
       ]
     },
-    "__schema726": {
+    "__schema732": {
       "markdownDescription": "An array where each item represents an IP range. The rule takes effect when an item matches the target IP. The syntax is the same as [`ip` in routing rules](https://xtls.github.io/en/config/routing.html#ruleobject). If omitted, all IPs are matched.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema727"
+          "$ref": "#/definitions/__schema733"
         }
       ]
     },
-    "__schema727": {
+    "__schema733": {
       "type": "array",
       "items": {
         "type": "string"
       }
     },
-    "__schema728": {
+    "__schema734": {
       "markdownDescription": "Sets how long the blackhole state lasts after a blocking rule matches.\n\nWhen a rule's `action` is `block` and the target matches, Freedom puts the connection into a blackhole state and closes it after this duration expires. The unit is seconds. It can be written as a fixed value or a range, for example `30` or `30-90`. If omitted, it defaults to `30-90`, which means a random value within that range.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema729"
+          "$ref": "#/definitions/__schema735"
         }
       ]
     },
-    "__schema729": {
+    "__schema735": {
       "type": "string"
     },
-    "__schema730": {
+    "__schema736": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema731"
+          "$ref": "#/definitions/__schema737"
         },
         "settings": {
-          "$ref": "#/definitions/__schema732"
+          "$ref": "#/definitions/__schema738"
         }
       },
       "required": [
@@ -9935,108 +10072,108 @@
       "additionalProperties": false,
       "markdownDescription": "DNS is an outbound protocol used to receive DNS queries sent in by routing, then forward or process them according to rules.\n\nThis outbound only supports traditional plaintext DNS queries over UDP and TCP; non-plaintext DNS protocols such as DoH, DoT, and DoQ are not applicable to this outbound. Common scenarios include TUN, transparent proxy, or `dokodemo-door` receiving DNS traffic and then routing sending that traffic to this outbound.\n\nIt can allow queries to the target DNS server, `hijack` them to the built-in [DNS server](https://xtls.github.io/en/config/dns.html) for further processing, drop them, or return responses with a specified RCODE according to rules. It can also rewrite the target address, port, and transport protocol.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/dns.html)\n"
     },
-    "__schema731": {
+    "__schema737": {
       "type": "string",
       "const": "dns"
     },
-    "__schema732": {
+    "__schema738": {
       "type": "object",
       "properties": {
         "rewriteNetwork": {
-          "$ref": "#/definitions/__schema733"
+          "$ref": "#/definitions/__schema739"
         },
         "rewriteAddress": {
-          "$ref": "#/definitions/__schema735"
+          "$ref": "#/definitions/__schema741"
         },
         "rewritePort": {
-          "$ref": "#/definitions/__schema737"
+          "$ref": "#/definitions/__schema743"
         },
         "userLevel": {
-          "$ref": "#/definitions/__schema739"
+          "$ref": "#/definitions/__schema745"
         },
         "rules": {
-          "$ref": "#/definitions/__schema741"
+          "$ref": "#/definitions/__schema747"
         }
       },
       "additionalProperties": false,
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n"
     },
-    "__schema733": {
+    "__schema739": {
       "markdownDescription": "Modifies the transport protocol used for DNS traffic. Available values are `\"tcp\"` and `\"udp\"`. If omitted, the original transport method is preserved.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema734"
+          "$ref": "#/definitions/__schema740"
         }
       ]
     },
-    "__schema734": {
+    "__schema740": {
       "type": "string",
       "enum": [
         "tcp",
         "udp"
       ]
     },
-    "__schema735": {
+    "__schema741": {
       "markdownDescription": "Modifies the DNS server address. If omitted, the address specified by the source is preserved.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema736"
+          "$ref": "#/definitions/__schema742"
         }
       ]
     },
-    "__schema736": {
+    "__schema742": {
       "type": "string"
     },
-    "__schema737": {
+    "__schema743": {
       "markdownDescription": "Modifies the DNS server port. If omitted, the port specified by the source is preserved.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema738"
+          "$ref": "#/definitions/__schema744"
         }
       ]
     },
-    "__schema738": {
+    "__schema744": {
       "type": "string"
     },
-    "__schema739": {
+    "__schema745": {
       "markdownDescription": "User level. Connections will use the [local policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `userLevel` corresponds to the `level` value in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If omitted, it defaults to `0`.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema740"
+          "$ref": "#/definitions/__schema746"
         }
       ]
     },
-    "__schema740": {
+    "__schema746": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema741": {
+    "__schema747": {
       "markdownDescription": "Matches DNS query rules in order, and supports fine-grained control by `qtype` and `domain`.\n\nIf no rule is matched, the built-in fallback rule is used: A and AAAA queries are imported into the built-in DNS module, while other query types return an empty response with RCODE `0`.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema742"
+          "$ref": "#/definitions/__schema748"
         }
       ]
     },
-    "__schema742": {
+    "__schema748": {
       "default": [],
       "type": "array",
       "items": {
         "type": "object",
         "properties": {
           "action": {
-            "$ref": "#/definitions/__schema743"
+            "$ref": "#/definitions/__schema749"
           },
           "qtype": {
-            "$ref": "#/definitions/__schema744"
+            "$ref": "#/definitions/__schema750"
           },
           "rCode": {
-            "$ref": "#/definitions/__schema746"
+            "$ref": "#/definitions/__schema752"
           },
           "domain": {
-            "$ref": "#/definitions/__schema748"
+            "$ref": "#/definitions/__schema754"
           }
         },
         "required": [
@@ -10047,7 +10184,7 @@
         "markdownDescription": "All matching conditions in a rule are combined with AND logic. If a condition is omitted, that condition is not restricted.\n"
       }
     },
-    "__schema743": {
+    "__schema749": {
       "type": "string",
       "enum": [
         "direct",
@@ -10057,15 +10194,15 @@
       ],
       "markdownDescription": "Defines the action to take when the rule matches.\n\n- `direct`: Allows the query directly to the target DNS server. If outbound-level `rewriteNetwork`, `rewriteAddress`, or `rewritePort` is also configured, the query is forwarded to the rewritten target.\n- `hijack`: Imports the query into the built-in [DNS server](https://xtls.github.io/en/config/dns.html) for further processing. This can be used for additional routing based on the built-in DNS configuration. Currently, only A and AAAA records are supported.\n- `drop`: Drops the request directly without returning a response.\n- `return`: Returns a DNS response whose response code is specified by `rCode`. Compared with `drop`, this can prevent some applications from waiting too long for a DNS timeout or repeatedly retrying.\n"
     },
-    "__schema744": {
+    "__schema750": {
       "markdownDescription": "Matches DNS query types. The forms are as follows:\n\n- Integer value: a specific query type, such as `\"qtype\": 1` for an A query, or `\"qtype\": 28` for an AAAA query.\n- String: can be a digits-only string such as `\"qtype\": \"28\"`, or a numeric range such as `\"qtype\": \"5-10\"`, which represents the 6 types from type 5 to type 10. Commas can be used for segmentation, such as `11,13,15-17`, which represents the 5 types: type 11, type 13, and type 15 to type 17.\n\nFor specific type numbers, refer to the [IANA documentation](https://www.iana.org/assignments/dns-parameters/dns-parameters.xhtml).\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema745"
+          "$ref": "#/definitions/__schema751"
         }
       ]
     },
-    "__schema745": {
+    "__schema751": {
       "anyOf": [
         {
           "type": "number"
@@ -10075,53 +10212,53 @@
         }
       ]
     },
-    "__schema746": {
+    "__schema752": {
       "markdownDescription": "The DNS RCODE used when returning a response, in the range `0` to `65535`. It only takes effect when `action` is `return`; if omitted, it defaults to `0`.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema747"
+          "$ref": "#/definitions/__schema753"
         }
       ]
     },
-    "__schema747": {
+    "__schema753": {
       "type": "number"
     },
-    "__schema748": {
+    "__schema754": {
       "type": "array",
       "items": {
-        "$ref": "#/definitions/__schema749"
+        "$ref": "#/definitions/__schema755"
       },
       "markdownDescription": "Matches a list of domains. The syntax is the same as [`domain` in routing rules](https://xtls.github.io/en/config/routing.html#ruleobject).\n"
     },
-    "__schema749": {
+    "__schema755": {
       "type": "string"
     },
-    "__schema750": {
+    "__schema756": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema751"
+          "$ref": "#/definitions/__schema757"
         },
         "settings": {
-          "$ref": "#/definitions/__schema752"
+          "$ref": "#/definitions/__schema758"
         }
       },
       "required": [
@@ -10131,21 +10268,21 @@
       "additionalProperties": false,
       "markdownDescription": "Client implementation of the Hysteria protocol.\n\nThis page is very simple because the Hysteria protocol is actually composed of a simple proxy control protocol and a tuned QUIC transport implementation. In Xray, the proxy protocol and transport configuration are separated. For more details (such as `brutal`), please refer to transport configuration items [hysteriaSettings](https://xtls.github.io/en/config/transports/hysteria.html) and [FinalMask.quicParams](https://xtls.github.io/en/config/transports/finalmask.html#quicparams).\n\n### TIP\n\nThe `hysteria protocol` itself has no authentication. When using with a non `hysteria` transport layer, it will be unable to proxy `udp`, and using it with other transport layers is not recommended.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/hysteria.html)\n"
     },
-    "__schema751": {
+    "__schema757": {
       "type": "string",
       "const": "hysteria"
     },
-    "__schema752": {
+    "__schema758": {
       "type": "object",
       "properties": {
         "version": {
-          "$ref": "#/definitions/__schema753"
+          "$ref": "#/definitions/__schema759"
         },
         "address": {
-          "$ref": "#/definitions/__schema754"
+          "$ref": "#/definitions/__schema760"
         },
         "port": {
-          "$ref": "#/definitions/__schema755"
+          "$ref": "#/definitions/__schema761"
         }
       },
       "required": [
@@ -10156,16 +10293,16 @@
       "additionalProperties": false,
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n"
     },
-    "__schema753": {
+    "__schema759": {
       "type": "number",
       "const": 2,
       "markdownDescription": "Hysteria version, must be 2.\n"
     },
-    "__schema754": {
+    "__schema760": {
       "type": "string",
       "markdownDescription": "Hysteria proxy server address, required.\n"
     },
-    "__schema755": {
+    "__schema761": {
       "markdownDescription": "Hysteria proxy server port, required.\n",
       "allOf": [
         {
@@ -10173,32 +10310,32 @@
         }
       ]
     },
-    "__schema756": {
+    "__schema762": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema757"
+          "$ref": "#/definitions/__schema763"
         },
         "settings": {
-          "$ref": "#/definitions/__schema758"
+          "$ref": "#/definitions/__schema764"
         }
       },
       "required": [
@@ -10208,15 +10345,15 @@
       "additionalProperties": false,
       "markdownDescription": "Loopback is an outbound data protocol. Its function is to re-inject data sent through this outbound back into the routing inbound, allowing the data to be processed by the routing system again without leaving Xray-core.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/loopback.html)\n"
     },
-    "__schema757": {
+    "__schema763": {
       "type": "string",
       "const": "loopback"
     },
-    "__schema758": {
+    "__schema764": {
       "type": "object",
       "properties": {
         "inboundTag": {
-          "$ref": "#/definitions/__schema759"
+          "$ref": "#/definitions/__schema765"
         }
       },
       "required": [
@@ -10225,36 +10362,36 @@
       "additionalProperties": false,
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n"
     },
-    "__schema759": {
+    "__schema765": {
       "type": "string",
       "markdownDescription": "The inbound protocol identifier used for re-routing.\n\nThis identifier can be used for `inboundTag` in routing rules, indicating that data from this outbound can be processed again by the corresponding routing rules.\n"
     },
-    "__schema760": {
+    "__schema766": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema761"
+          "$ref": "#/definitions/__schema767"
         },
         "settings": {
-          "$ref": "#/definitions/__schema762"
+          "$ref": "#/definitions/__schema768"
         }
       },
       "required": [
@@ -10264,14 +10401,14 @@
       "additionalProperties": false,
       "markdownDescription": "The [Shadowsocks](https://en.wikipedia.org/wiki/Shadowsocks) protocol, compatible with most other version implementations.\n\nCurrent compatibility is as follows:\n\n- Supports TCP and UDP packet forwarding, where UDP can be optionally disabled;\n- Recommended encryption methods:\n  - 2022-blake3-aes-128-gcm\n  - 2022-blake3-aes-256-gcm\n  - 2022-blake3-chacha20-poly1305\n- Other encryption methods:\n  - aes-256-gcm\n  - aes-128-gcm\n  - chacha20-poly1305 (or chacha20-ietf-poly1305)\n  - xchacha20-poly1305 (or xchacha20-ietf-poly1305)\n  - none (or plain)\n\nThe Shadowsocks 2022 new protocol format improves performance and includes complete replay protection, resolving the following security issues of the old protocol:\n\n- [Severe vulnerabilities in the design of Shadowsocks AEAD encryption, unable to guarantee communication reliability](https://github.com/shadowsocks/shadowsocks-org/issues/183)\n- The false positive rate of the original TCP replay filter increases over time\n- No UDP replay protection\n- TCP behavior that can be used for active probing\n\n### DANGER\n\nUnder the \"none\" encryption method, traffic will be transmitted in plain text. To ensure security, do not use it on public networks.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/shadowsocks.html)\n"
     },
-    "__schema761": {
+    "__schema767": {
       "type": "string",
       "const": "shadowsocks"
     },
-    "__schema762": {
+    "__schema768": {
       "anyOf": [
         {
-          "$ref": "#/definitions/__schema763"
+          "$ref": "#/definitions/__schema769"
         },
         {
           "type": "object",
@@ -10279,7 +10416,7 @@
             "servers": {
               "type": "array",
               "items": {
-                "$ref": "#/definitions/__schema763"
+                "$ref": "#/definitions/__schema769"
               }
             }
           },
@@ -10290,7 +10427,7 @@
         }
       ]
     },
-    "__schema763": {
+    "__schema769": {
       "type": "object",
       "properties": {
         "address": {
@@ -10309,7 +10446,7 @@
           "markdownDescription": "Email address, optional, used to identify the user.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema764"
+              "$ref": "#/definitions/__schema770"
             }
           ]
         },
@@ -10318,17 +10455,17 @@
           "markdownDescription": "Shadowsocks authentication password. Required.\n\n- Shadowsocks 2022\n\nUses a pre-shared key similar to WireGuard as the password.\n\nUse `openssl rand -base64 <length>` to generate a key compatible with shadowsocks-rust. The length depends on the encryption method used.\n\n| Encryption Method             | Key Length |\n| ----------------------------- | ---------- |\n| 2022-blake3-aes-128-gcm       | 16         |\n| 2022-blake3-aes-256-gcm       | 32         |\n| 2022-blake3-chacha20-poly1305 | 32         |\n\nIn the Go implementation, 32-byte keys always work.\n\n- Other encryption methods\n\nAny string. There is no limit on password length, but short passwords are more likely to be cracked. It is recommended to use passwords of 16 characters or longer.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema765"
+              "$ref": "#/definitions/__schema771"
             }
           ]
         },
         "method": {
           "anyOf": [
             {
-              "$ref": "#/definitions/__schema604"
+              "$ref": "#/definitions/__schema606"
             },
             {
-              "$ref": "#/definitions/__schema609"
+              "$ref": "#/definitions/__schema614"
             }
           ],
           "markdownDescription": "Shadowsocks encryption method. Required.\n\nRecommended encryption methods:\n\n- 2022-blake3-aes-128-gcm\n- 2022-blake3-aes-256-gcm\n- 2022-blake3-chacha20-poly1305\n\nOther encryption methods:\n\n- aes-256-gcm\n- aes-128-gcm\n- chacha20-poly1305 (or chacha20-ietf-poly1305)\n- xchacha20-poly1305 (or xchacha20-ietf-poly1305)\n- none (or plain)\n"
@@ -10337,7 +10474,7 @@
           "markdownDescription": "Enable `udp over tcp`.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema766"
+              "$ref": "#/definitions/__schema772"
             }
           ]
         },
@@ -10345,7 +10482,7 @@
           "markdownDescription": "Implementation version of `UDP over TCP`.\n\nCurrent optional values: `1`, `2`.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema767"
+              "$ref": "#/definitions/__schema773"
             }
           ]
         },
@@ -10353,7 +10490,7 @@
           "markdownDescription": "User level. The connection will use the [local policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `level` corresponds to the `level` value in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, the default is 0.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema768"
+              "$ref": "#/definitions/__schema774"
             }
           ]
         }
@@ -10366,17 +10503,17 @@
       ],
       "additionalProperties": false
     },
-    "__schema764": {
+    "__schema770": {
       "type": "string"
     },
-    "__schema765": {
+    "__schema771": {
       "type": "string"
     },
-    "__schema766": {
+    "__schema772": {
       "default": true,
       "type": "boolean"
     },
-    "__schema767": {
+    "__schema773": {
       "default": 2,
       "anyOf": [
         {
@@ -10389,38 +10526,38 @@
         }
       ]
     },
-    "__schema768": {
+    "__schema774": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema769": {
+    "__schema775": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema770"
+          "$ref": "#/definitions/__schema776"
         },
         "settings": {
-          "$ref": "#/definitions/__schema771"
+          "$ref": "#/definitions/__schema777"
         }
       },
       "required": [
@@ -10429,14 +10566,14 @@
       "additionalProperties": false,
       "markdownDescription": "Standard Socks protocol implementation, compatible with Socks 5.\n\n### DANGER\n\n**The Socks protocol does not encrypt transmission and is not suitable for transmission over the public internet.**\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/socks.html)\n"
     },
-    "__schema770": {
+    "__schema776": {
       "type": "string",
       "const": "socks"
     },
-    "__schema771": {
+    "__schema777": {
       "anyOf": [
         {
-          "$ref": "#/definitions/__schema772"
+          "$ref": "#/definitions/__schema778"
         },
         {
           "type": "object",
@@ -10444,7 +10581,7 @@
             "servers": {
               "type": "array",
               "items": {
-                "$ref": "#/definitions/__schema772"
+                "$ref": "#/definitions/__schema778"
               }
             }
           },
@@ -10455,26 +10592,26 @@
         }
       ]
     },
-    "__schema772": {
+    "__schema778": {
       "type": "object",
       "properties": {
         "address": {
-          "$ref": "#/definitions/__schema773"
+          "$ref": "#/definitions/__schema779"
         },
         "port": {
-          "$ref": "#/definitions/__schema774"
+          "$ref": "#/definitions/__schema780"
         },
         "user": {
-          "$ref": "#/definitions/__schema775"
+          "$ref": "#/definitions/__schema781"
         },
         "pass": {
-          "$ref": "#/definitions/__schema777"
+          "$ref": "#/definitions/__schema783"
         },
         "level": {
-          "$ref": "#/definitions/__schema779"
+          "$ref": "#/definitions/__schema785"
         },
         "email": {
-          "$ref": "#/definitions/__schema781"
+          "$ref": "#/definitions/__schema787"
         }
       },
       "required": [
@@ -10484,11 +10621,11 @@
       "additionalProperties": false,
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n"
     },
-    "__schema773": {
+    "__schema779": {
       "type": "string",
       "markdownDescription": "Server address. Required.\n\n### TIP\n\nOnly connections to Socks 5 servers are supported.\n"
     },
-    "__schema774": {
+    "__schema780": {
       "markdownDescription": "Server port. Required.\n",
       "allOf": [
         {
@@ -10496,79 +10633,79 @@
         }
       ]
     },
-    "__schema775": {
+    "__schema781": {
       "markdownDescription": "Username, string type. Required if the remote server requires authentication; otherwise, do not include this item.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema776"
+          "$ref": "#/definitions/__schema782"
         }
       ]
     },
-    "__schema776": {
+    "__schema782": {
       "type": "string"
     },
-    "__schema777": {
+    "__schema783": {
       "markdownDescription": "Password, string type. Required if the remote server requires authentication; otherwise, do not include this item.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema778"
+          "$ref": "#/definitions/__schema784"
         }
       ]
     },
-    "__schema778": {
+    "__schema784": {
       "type": "string"
     },
-    "__schema779": {
+    "__schema785": {
       "markdownDescription": "User level. The connection will use the [local policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `userLevel` corresponds to the value of `level` in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, the default is 0.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema780"
+          "$ref": "#/definitions/__schema786"
         }
       ]
     },
-    "__schema780": {
+    "__schema786": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema781": {
+    "__schema787": {
       "markdownDescription": "Email address, used to identify the user.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema782"
+          "$ref": "#/definitions/__schema788"
         }
       ]
     },
-    "__schema782": {
+    "__schema788": {
       "type": "string"
     },
-    "__schema783": {
+    "__schema789": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema784"
+          "$ref": "#/definitions/__schema790"
         },
         "settings": {
-          "$ref": "#/definitions/__schema785"
+          "$ref": "#/definitions/__schema791"
         }
       },
       "required": [
@@ -10578,22 +10715,22 @@
       "additionalProperties": false,
       "markdownDescription": "[Trojan](https://trojan-gfw.github.io/trojan/protocol) protocol.\n\n### DANGER\n\nTrojan is designed to work over a correctly configured encrypted TLS tunnel.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/trojan.html)\n"
     },
-    "__schema784": {
+    "__schema790": {
       "type": "string",
       "const": "trojan"
     },
-    "__schema785": {
+    "__schema791": {
       "anyOf": [
         {
-          "$ref": "#/definitions/__schema786"
+          "$ref": "#/definitions/__schema792"
         },
         {
-          "$ref": "#/definitions/__schema789"
+          "$ref": "#/definitions/__schema795"
         }
       ],
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n"
     },
-    "__schema786": {
+    "__schema792": {
       "type": "object",
       "properties": {
         "address": {
@@ -10612,7 +10749,7 @@
           "markdownDescription": "Email address. Optional, used to identify the user.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema787"
+              "$ref": "#/definitions/__schema793"
             }
           ]
         },
@@ -10624,7 +10761,7 @@
           "markdownDescription": "User level. Connections will use the [Local Policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `level` corresponds to the value of `level` in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, it defaults to 0.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema788"
+              "$ref": "#/definitions/__schema794"
             }
           ]
         }
@@ -10635,22 +10772,22 @@
       ],
       "additionalProperties": false
     },
-    "__schema787": {
+    "__schema793": {
       "type": "string"
     },
-    "__schema788": {
+    "__schema794": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema789": {
+    "__schema795": {
       "type": "object",
       "properties": {
         "servers": {
           "type": "array",
           "items": {
-            "$ref": "#/definitions/__schema786"
+            "$ref": "#/definitions/__schema792"
           },
           "markdownDescription": "An array of Trojan server configurations.\n"
         }
@@ -10660,32 +10797,32 @@
       ],
       "additionalProperties": false
     },
-    "__schema790": {
+    "__schema796": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema791"
+          "$ref": "#/definitions/__schema797"
         },
         "settings": {
-          "$ref": "#/definitions/__schema792"
+          "$ref": "#/definitions/__schema798"
         }
       },
       "required": [
@@ -10695,33 +10832,33 @@
       "additionalProperties": false,
       "markdownDescription": "VLESS is a stateless lightweight transport protocol. It consists of inbound and outbound parts and can serve as a bridge between the Xray client and server.\n\nUnlike [VMess](https://xtls.github.io/en/config/outbounds/vmess.html), VLESS does not depend on system time. The authentication method is also UUID.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/vless.html)\n"
     },
-    "__schema791": {
+    "__schema797": {
       "type": "string",
       "const": "vless"
     },
-    "__schema792": {
+    "__schema798": {
       "type": "object",
       "properties": {
         "address": {
-          "$ref": "#/definitions/__schema793"
+          "$ref": "#/definitions/__schema799"
         },
         "port": {
-          "$ref": "#/definitions/__schema794"
+          "$ref": "#/definitions/__schema800"
         },
         "id": {
-          "$ref": "#/definitions/__schema795"
+          "$ref": "#/definitions/__schema801"
         },
         "encryption": {
-          "$ref": "#/definitions/__schema796"
+          "$ref": "#/definitions/__schema802"
         },
         "flow": {
-          "$ref": "#/definitions/__schema798"
+          "$ref": "#/definitions/__schema804"
         },
         "level": {
-          "$ref": "#/definitions/__schema800"
+          "$ref": "#/definitions/__schema806"
         },
         "reverse": {
-          "$ref": "#/definitions/__schema802"
+          "$ref": "#/definitions/__schema808"
         }
       },
       "required": [
@@ -10733,11 +10870,11 @@
       "additionalProperties": false,
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n"
     },
-    "__schema793": {
+    "__schema799": {
       "type": "string",
       "markdownDescription": "Server address, points to the server. Supports domain names, IPv4, and IPv6.\n"
     },
-    "__schema794": {
+    "__schema800": {
       "markdownDescription": "Server port, usually the same as the port the server is listening on.\n",
       "allOf": [
         {
@@ -10745,31 +10882,31 @@
         }
       ]
     },
-    "__schema795": {
+    "__schema801": {
       "type": "string",
       "markdownDescription": "User ID for VLESS. It can be any string less than 30 bytes, or a valid UUID. A custom string and its mapped UUID are equivalent.\n\nThe mapping standard is described in [VLESS UUID Mapping Standard: Mapping Custom Strings to UUIDv5](https://github.com/XTLS/Xray-core/issues/158).\n\nYou can use the command `xray uuid -i \"custom string\"` to generate the UUID mapped from a custom string, or use the command `xray uuid` to generate a random UUID.\n"
     },
-    "__schema796": {
+    "__schema802": {
       "default": "none",
       "markdownDescription": "[VLESS Encryption](https://github.com/XTLS/Xray-core/pull/5067) settings. Cannot be left empty; to disable, explicitly set to `\"none\"`.\n\nIt is recommended for most users to use the `xray vlessenc` command to automatically generate this field to avoid configuration mistakes. The detailed configuration below is recommended only for advanced users.\n\nIts format is a detailed configuration string of fields connected by `.`. For example: `mlkem768x25519plus.native.0rtt.100-111-1111.75-0-111.50-0-3333.ptjHQxBQxTJ9MWr2cd5qWIflBSACHOevTauCQwa_71U`. This document will refer to the separate parts separated by dots as \"blocks\".\n\n- **The 1st block** is the handshake method. Currently, there is only `mlkem768x25519plus`. Requires consistency between server and client.\n- **The 2nd block** is the encryption method. Options are `native`/`xorpub`/`random`, corresponding to: raw format packet / raw format + obfuscated public key part / fully random numbers (similar to VMESS/Shadowsocks). Requires consistency between server and client.\n- **The 3rd block** is session resumption. Choosing `0rtt` will follow the server settings to attempt to use previously generated tickets to skip the handshake for fast connection (can be manually disabled by the server). Choosing `1rtt` will force a 1-RTT handshake process. The meaning here differs from the server setting; see VLESS Inbound `decryption` settings for details.\n\nFollowing blocks are **padding**. After the connection is established, the client sends some garbage data to obfuscate length characteristics. It does not need to be the same as the server (the corresponding part in the inbound is the padding sent from the server to the client). It is a variable-length part with the format `padding.delay.padding` + `(.delay.padding)` x n (multiple padding blocks can be inserted, requiring a delay block between two padding blocks).\n\n- `padding` format is `probability-min-max`. E.g., `100-111-1111` means 100% probability to send a padding of length 111~1111.\n- `delay` format is also `probability-min-max`. E.g., `75-0-111` means 75% probability to wait 0~111 milliseconds.\n\nThe first padding block has special requirements: probability must be 100% and minimum length greater than 0. If no padding exists, the core automatically uses `100-111-1111.75-0-111.50-0-3333` as the padding setting.\n\n**The last block** will be recognized by the core as the parameter used to authenticate the server. It can be generated by `./xray x25519` (using the Password part) or `./xray mlkem768` (using the Client part). It must correspond to the server. `mlkem768` belongs to post-quantum algorithms, preventing (future) client parameter leaks from allowing quantum computers to crack the private key and impersonate the server. This parameter is only used for verification; the handshake process is post-quantum secure regardless, and existing encrypted data cannot be decrypted by future quantum computers.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema797"
+          "$ref": "#/definitions/__schema803"
         }
       ]
     },
-    "__schema797": {
+    "__schema803": {
       "type": "string"
     },
-    "__schema798": {
+    "__schema804": {
       "markdownDescription": "Flow control mode, used to select the XTLS algorithm.\n\nCurrently, the following flow control modes are available in the outbound protocol:\n\n- **No `flow` or empty string**: Use standard TLS proxy.\n- **`xtls-rprx-vision`**: Use XTLS, including inner handshake random padding. Will intercept UDP traffic targeting port 443 (QUIC) to force browsers to use standard HTTPS, increasing traffic that can be Spliced.\n- **`xtls-rprx-vision-udp443`**: Same as `xtls-rprx-vision`, but does not intercept UDP 443. Used when a program forces the use of QUIC and would fail to work if intercepted.\n\nXTLS is available only in the following combinations:\n\n- **TCP+TLS/REALITY**: In this case, if transmitting TLS 1.3, the core will attempt to Splice encrypted data at the bottom layer. If successful, it saves all core IO overhead.\n- **VLESS Encryption**: No underlying transport restrictions. If the underlying transport is not TCP, it only attempts to penetrate Encryption, saving Encryption overhead. If it is TCP, it will still attempt to perform Splice.\n\n### TIP\n\nSplice is a function provided by the Linux Kernel. The system kernel forwards TCP directly, no longer passing through Xray's memory, greatly reducing data copying and CPU context switching.\n\nWhen using Vision mode, Splice is automatically enabled if the following conditions are met:\n\n- Linux environment.\n- Inbound protocol is a pure TCP connection like `Dokodemo door`, `Socks`, `HTTP`, or other inbound protocols using XTLS.\n- Outbound protocol is VLESS + XTLS.\n\nWhen using Splice, the network speed display will lag and will only be counted after the connection is disconnected because the core cannot know the traffic situation while the kernel takes over the connection.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema799"
+          "$ref": "#/definitions/__schema805"
         }
       ]
     },
-    "__schema799": {
+    "__schema805": {
       "type": "string",
       "enum": [
         "",
@@ -10777,29 +10914,29 @@
         "xtls-rprx-vision-udp443"
       ]
     },
-    "__schema800": {
+    "__schema806": {
       "markdownDescription": "User level. The connection will use the [Local Policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `level` corresponds to the value of `level` in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, it defaults to 0.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema801"
+          "$ref": "#/definitions/__schema807"
         }
       ]
     },
-    "__schema801": {
+    "__schema807": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema802": {
+    "__schema808": {
       "markdownDescription": "VLESS minimalist reverse proxy configuration. It preserves the real source IP information from the public-facing side.\n\nThe existence of this item indicates that this outbound can be used as a VLESS reverse proxy outbound, and it will automatically establish a connection to the server to register the reverse proxy tunnel.\n\n`tag` is the inbound proxy tag for this reverse proxy. When the server dispatches a reverse proxy request, it enters the routing system from the inbound using this tag, and the routing system routes it to the outbound you need.\n\nThe UUID used must be one that is also configured with `reverse` on the server side (see VLESS Inbound for details).\n\n`sniffing` see [SniffingObject](https://xtls.github.io/en/config/inbound.html#sniffingobject), performs sniffing on requests entering through this reverse proxy.\n\n### TIP\n\nFull tutorial: [VLESS Reverse Proxy Examples](https://xtls.github.io/en/document/level-2/vless_reverse.html)\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema803"
+          "$ref": "#/definitions/__schema809"
         }
       ]
     },
-    "__schema803": {
+    "__schema809": {
       "type": "object",
       "properties": {
         "tag": {
@@ -10819,32 +10956,32 @@
       ],
       "additionalProperties": false
     },
-    "__schema804": {
+    "__schema810": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema805"
+          "$ref": "#/definitions/__schema811"
         },
         "settings": {
-          "$ref": "#/definitions/__schema806"
+          "$ref": "#/definitions/__schema812"
         }
       },
       "required": [
@@ -10854,30 +10991,30 @@
       "additionalProperties": false,
       "markdownDescription": "[VMess](https://xtls.github.io/en/development/protocols/vmess.html) is an encrypted transport protocol, usually serving as a bridge between the Xray client and server.\n\n### DANGER\n\nVMess depends on system time. Please ensure that the UTC time of the system running Xray is within 120 seconds of the actual time, independent of the time zone. On Linux systems, you can install the `ntp` service to automatically synchronize the system time.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/vmess.html)\n"
     },
-    "__schema805": {
+    "__schema811": {
       "type": "string",
       "const": "vmess"
     },
-    "__schema806": {
+    "__schema812": {
       "type": "object",
       "properties": {
         "address": {
-          "$ref": "#/definitions/__schema807"
+          "$ref": "#/definitions/__schema813"
         },
         "port": {
-          "$ref": "#/definitions/__schema808"
+          "$ref": "#/definitions/__schema814"
         },
         "id": {
-          "$ref": "#/definitions/__schema809"
+          "$ref": "#/definitions/__schema815"
         },
         "security": {
-          "$ref": "#/definitions/__schema810"
+          "$ref": "#/definitions/__schema816"
         },
         "level": {
-          "$ref": "#/definitions/__schema812"
+          "$ref": "#/definitions/__schema818"
         },
         "experiments": {
-          "$ref": "#/definitions/__schema814"
+          "$ref": "#/definitions/__schema820"
         }
       },
       "required": [
@@ -10888,11 +11025,11 @@
       "additionalProperties": false,
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n"
     },
-    "__schema807": {
+    "__schema813": {
       "type": "string",
       "markdownDescription": "Server address, supports IP address or domain name.\n"
     },
-    "__schema808": {
+    "__schema814": {
       "markdownDescription": "The port number the server is listening on. Required.\n",
       "allOf": [
         {
@@ -10900,19 +11037,19 @@
         }
       ]
     },
-    "__schema809": {
+    "__schema815": {
       "type": "string",
       "markdownDescription": "VMess User ID. It can be any string less than 30 bytes or a valid UUID.\n\nA custom string and its mapped UUID are equivalent. This means you can identify the same user in the configuration file like this:\n\n- Write `\"id\": \"我爱🍉老师1314\"`,\n- Or write `\"id\": \"5783a3e7-e373-51cd-8642-c83782b807c5\"` (This UUID is the UUID mapping of `我爱🍉老师1314`)\n\nThe mapping standard is described in [VLESS UUID Mapping Standard: Mapping Custom Strings to a UUIDv5](https://github.com/XTLS/Xray-core/issues/158).\n\nYou can use the command `xray uuid -i \"custom string\"` to generate the UUID mapped from the custom string. You can also use the command `xray uuid` to generate a random UUID.\n"
     },
-    "__schema810": {
+    "__schema816": {
       "markdownDescription": "Encryption method. The client will use the configured encryption method to send data, and the server will automatically identify it without configuration.\n\n- `\"aes-128-gcm\"`: Use AES-128-GCM algorithm.\n- `\"chacha20-poly1305\"`: Use Chacha20-Poly1305 algorithm.\n- `\"auto\"`: Default value. Automatically selected (uses aes-128-gcm encryption when the running framework is AMD64, ARM64, or s390x; uses Chacha20-Poly1305 encryption in other cases).\n- `\"none\"`: No encryption, maintains the VMess message structure.\n- `\"zero\"`: No encryption, direct stream copy (similar to VLESS).\n\nIt is not recommended to use `\"none\"` or `\"zero\"` pseudo-encryption methods without enabling TLS encryption and enforcing certificate verification. Regardless of the encryption method used, the VMess packet header is protected by encryption and authentication.\n\nNote: `\"auto\"` only determines the AES hardware acceleration support status of the _client_. If the _server_ does not support AES hardware acceleration, you still need to manually set it to `chacha20-poly1305`. This is very important because Chacha20-Poly1305 takes about 48% more time than AES-128-GCM on platforms supporting AES acceleration, but on platforms _without_ AES acceleration, AES-128-GCM takes over 2000% more time than Chacha20-Poly1305.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema811"
+          "$ref": "#/definitions/__schema817"
         }
       ]
     },
-    "__schema811": {
+    "__schema817": {
       "type": "string",
       "enum": [
         "aes-128-gcm",
@@ -10922,29 +11059,29 @@
         "zero"
       ]
     },
-    "__schema812": {
+    "__schema818": {
       "markdownDescription": "User level. The connection will use the [local policy](https://xtls.github.io/en/config/policy.html#levelpolicyobject) corresponding to this user level.\n\nThe value of `level` corresponds to the value of `level` in [policy](https://xtls.github.io/en/config/policy.html#policyobject). If not specified, the default is 0.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema813"
+          "$ref": "#/definitions/__schema819"
         }
       ]
     },
-    "__schema813": {
+    "__schema819": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema814": {
+    "__schema820": {
       "markdownDescription": "Enabled VMess protocol experimental features. (Features here are unstable and may be removed at any time). Multiple enabled experiments can be separated by the `|` character, such as `\"AuthenticatedLength|NoTerminationSignal\"`.\n\n- `\"AuthenticatedLength\"`: Enable authenticated packet length experiment. This experiment requires both the client and server to enable it simultaneously and run the same version of the program.\n- `\"NoTerminationSignal\"`: Enable not sending the disconnection signal. This feature is now enabled by default.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema815"
+          "$ref": "#/definitions/__schema821"
         }
       ]
     },
-    "__schema815": {
+    "__schema821": {
       "type": "string",
       "enum": [
         "AuthenticatedLength",
@@ -10952,32 +11089,32 @@
         "AuthenticatedLength|NoTerminationSignal"
       ]
     },
-    "__schema816": {
+    "__schema822": {
       "type": "object",
       "properties": {
         "sendThrough": {
-          "$ref": "#/definitions/__schema689"
+          "$ref": "#/definitions/__schema695"
         },
         "tag": {
-          "$ref": "#/definitions/__schema691"
+          "$ref": "#/definitions/__schema697"
         },
         "streamSettings": {
-          "$ref": "#/definitions/__schema693"
+          "$ref": "#/definitions/__schema699"
         },
         "targetStrategy": {
-          "$ref": "#/definitions/__schema694"
+          "$ref": "#/definitions/__schema700"
         },
         "proxySettings": {
-          "$ref": "#/definitions/__schema696"
+          "$ref": "#/definitions/__schema702"
         },
         "mux": {
-          "$ref": "#/definitions/__schema699"
+          "$ref": "#/definitions/__schema705"
         },
         "protocol": {
-          "$ref": "#/definitions/__schema817"
+          "$ref": "#/definitions/__schema823"
         },
         "settings": {
-          "$ref": "#/definitions/__schema818"
+          "$ref": "#/definitions/__schema824"
         }
       },
       "required": [
@@ -10987,36 +11124,36 @@
       "additionalProperties": false,
       "markdownDescription": "Standard Wireguard protocol implementation.\n\n### DANGER\n\n**The Wireguard protocol is not designed specifically for bypassing firewalls. If used at the outermost layer to cross the Great Firewall, distinctive characteristics may lead to the server being blocked.**\n\n### TIP\n\nCurrently, configuring `streamSettings` is not supported in the Wireguard protocol outbound.\n\n[Documentation ↗](https://xtls.github.io/en/config/outbounds/wireguard.html)\n"
     },
-    "__schema817": {
+    "__schema823": {
       "type": "string",
       "const": "wireguard"
     },
-    "__schema818": {
+    "__schema824": {
       "type": "object",
       "properties": {
         "secretKey": {
-          "$ref": "#/definitions/__schema819"
+          "$ref": "#/definitions/__schema825"
         },
         "address": {
-          "$ref": "#/definitions/__schema820"
+          "$ref": "#/definitions/__schema826"
         },
         "peers": {
-          "$ref": "#/definitions/__schema822"
+          "$ref": "#/definitions/__schema828"
         },
         "noKernelTun": {
-          "$ref": "#/definitions/__schema827"
+          "$ref": "#/definitions/__schema833"
         },
         "mtu": {
-          "$ref": "#/definitions/__schema829"
+          "$ref": "#/definitions/__schema835"
         },
         "reserved": {
-          "$ref": "#/definitions/__schema831"
+          "$ref": "#/definitions/__schema837"
         },
         "workers": {
-          "$ref": "#/definitions/__schema833"
+          "$ref": "#/definitions/__schema839"
         },
         "domainStrategy": {
-          "$ref": "#/definitions/__schema835"
+          "$ref": "#/definitions/__schema841"
         }
       },
       "required": [
@@ -11028,30 +11165,30 @@
       "additionalProperties": false,
       "markdownDescription": "`OutboundConfigurationObject` corresponds to the `settings` item in [`OutboundObject`](https://xtls.github.io/en/config/outbound.html).\n"
     },
-    "__schema819": {
+    "__schema825": {
       "type": "string",
       "markdownDescription": "User private key. Required.\n"
     },
-    "__schema820": {
+    "__schema826": {
       "minItems": 1,
       "type": "array",
       "items": {
-        "$ref": "#/definitions/__schema821"
+        "$ref": "#/definitions/__schema827"
       },
       "markdownDescription": "Wireguard will start a virtual network interface (tun) locally. Use one or more IP addresses; IPv6 is supported.\n"
     },
-    "__schema821": {
+    "__schema827": {
       "type": "string"
     },
-    "__schema822": {
+    "__schema828": {
       "minItems": 1,
       "type": "array",
       "items": {
-        "$ref": "#/definitions/__schema823"
+        "$ref": "#/definitions/__schema829"
       },
       "markdownDescription": "List of Wireguard servers, where each item is a server configuration.\n"
     },
-    "__schema823": {
+    "__schema829": {
       "type": "object",
       "properties": {
         "endpoint": {
@@ -11066,7 +11203,7 @@
           "markdownDescription": "Additional symmetric encryption key.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema824"
+              "$ref": "#/definitions/__schema830"
             }
           ]
         },
@@ -11074,7 +11211,7 @@
           "markdownDescription": "Heartbeat interval in seconds. Default is 0, meaning no heartbeat.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema825"
+              "$ref": "#/definitions/__schema831"
             }
           ]
         },
@@ -11082,7 +11219,7 @@
           "markdownDescription": "Wireguard only allows traffic from specific source IPs.\n",
           "allOf": [
             {
-              "$ref": "#/definitions/__schema826"
+              "$ref": "#/definitions/__schema832"
             }
           ]
         }
@@ -11093,16 +11230,16 @@
       ],
       "additionalProperties": false
     },
-    "__schema824": {
+    "__schema830": {
       "type": "string"
     },
-    "__schema825": {
+    "__schema831": {
       "default": 0,
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema826": {
+    "__schema832": {
       "default": [
         "0.0.0.0/0",
         "::/0"
@@ -11112,41 +11249,41 @@
         "type": "string"
       }
     },
-    "__schema827": {
+    "__schema833": {
       "markdownDescription": "By default, the core detects if it is running on Linux and if the current user has `CAP_NET_ADMIN` permissions to decide whether to enable the system virtual network interface; otherwise, it uses gVisor. Using the system virtual interface offers relatively higher performance. Note that this is only for processing IP packets and has nothing to do with the wireguard kernel module.\n\nThis detection may not always be accurate. For example, some LXC virtualization environments may not have TUN permissions at all, causing the outbound to fail. Therefore, you can set this option to manually disable it.\n\nWhen using the system virtual interface, it occupies IPv6 routing table number `10230`. Each additional Wireguard outbound will use subsequent routing tables sequentially; for example, the second one will use routing table `10231`, and so on.\n\nNote that if a second Xray instance is started on the same machine, it will not assign the next routing table number but will continue trying to use routing table `10230`. Since it is already occupied by the first Xray instance, it will fail to connect. If absolutely needed, you must set this option to disable the system virtual interface.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema828"
+          "$ref": "#/definitions/__schema834"
         }
       ]
     },
-    "__schema828": {
+    "__schema834": {
       "default": false,
       "type": "boolean"
     },
-    "__schema829": {
+    "__schema835": {
       "default": 1420,
       "markdownDescription": "MTU size of the underlying Wireguard tun.\n\nThe structure of a Wireguard packet is as follows:\n\n- 20-byte IPv4 header or 40 byte IPv6 header\n- 8-byte UDP header\n- 4-byte type\n- 4-byte key index\n- 8-byte nonce\n- N-byte encrypted data\n- 16-byte authentication tag\n\n`N-byte encrypted data` is the MTU value we need. Depending on whether the endpoint is IPv4 or IPv6, the specific value can be 1440 (IPv4) or 1420 (IPv6). If in a special environment, subtract further (e.g., home broadband PPPoE requires an extra -8).\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema830"
+          "$ref": "#/definitions/__schema836"
         }
       ]
     },
-    "__schema830": {
+    "__schema836": {
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema831": {
+    "__schema837": {
       "markdownDescription": "Wireguard reserved bytes, fill as needed.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema832"
+          "$ref": "#/definitions/__schema838"
         }
       ]
     },
-    "__schema832": {
+    "__schema838": {
       "default": [],
       "type": "array",
       "items": {
@@ -11155,28 +11292,28 @@
         "maximum": 9007199254740991
       }
     },
-    "__schema833": {
+    "__schema839": {
       "markdownDescription": "Number of threads used by Wireguard. Defaults to the number of system cores.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema834"
+          "$ref": "#/definitions/__schema840"
         }
       ]
     },
-    "__schema834": {
+    "__schema840": {
       "type": "integer",
       "minimum": -9007199254740991,
       "maximum": 9007199254740991
     },
-    "__schema835": {
+    "__schema841": {
       "markdownDescription": "Controls the domain resolution strategy when the Wireguard server address is a domain name or the target address of the proxied traffic is a domain name.\n\nUnlike most proxy protocols, Wireguard does not allow passing domain names as targets. Therefore, if the incoming target is a domain, it needs to be resolved to an IP address before transmission. This is handled by Xray's built-in DNS. The meaning of this field is the same as `domainStrategy` in `Freedom` outbound. The default value is `ForceIP`.\n\nThe `domainStrategy` of `Freedom` outbound includes options like `UseIP`, which are not provided here because Wireguard must obtain a usable IP and cannot perform the behavior of falling back to a domain name after `UseIP` resolution fails.\n\nNote: When applied to proxied traffic, this option is also constrained by the `address` option. For example, if you set `ForceIPv6v4` but no IPv6 address is set in `address`, even if the target domain has AAAA records, they will not be resolved/used.\n",
       "allOf": [
         {
-          "$ref": "#/definitions/__schema836"
+          "$ref": "#/definitions/__schema842"
         }
       ]
     },
-    "__schema836": {
+    "__schema842": {
       "default": "ForceIP",
       "type": "string",
       "enum": [