@regle/mcp-server 1.18.0-beta.1 → 1.18.0-beta.2

package/dist/regle-mcp-server.js

@@ -50,6 +50,13 @@ var docs_data_default = {
 			"path": "advanced-usage/scoped-validation.md",
 			"content": "# Scoped validation\n\nScoped validation in Regle is made to port Vuelidate's `nested component validation`.\n\nProblems with Vuelidate's approach:\n - Performances\n - Not declarative\n - Usage (too magic for the user)\n - Type safety\n - Restricted to DOM\n - Have to play with `$scope` and `$stopPropagation` to avoid unwanted behaviour\n\nRegle's solution solves all this problems\n\n## Collecting validation with `useCollectScope` and `useScopedRegle`\n\n### `useScopedRegle`\n\n`useScopedRegle` is a clone of `useRegle`, but with the difference that every time it's used and updated, its state will be collected by the same scope created using `createScopedUseRegle`.\n\nEvery time it's called, a instance will be added for `useCollectScope` to collect.\n\nIt can be called multiple times at any place, not only on components, as it's not restricted by DOM.\n\n### `useCollectScope`\n\nThis composable allow you to retrieve every Regle instances created using the sibling composable `useScopedRegle`.\n\nChildren properties like `$value` and `$errors` will not be objects, and are converted into arrays instead.\n\nYou will also have access to every validation properties like `$error`, `$invalid` etc...\n\n:::code-group\n\n```vue [Parent.vue]\n<template>\n  <div>\n    <Child1 />\n  </div>\n\n  <Child2 />\n\n  Collected errors: <pre>{{ r$.$errors }}</pre>\n</template>\n\n```\n\n```vue [Child1.vue]\n<template>\n  <input v-model=\"r$.$value.firstName\" placeholder=\"Type your firstname\" />\n  <ul>\n    <li v-for=\"error of r$.$errors.firstName\" :key=\"error\">\n      {{ error }}\n    </li>\n  </ul>\n</template>\n\n```\n\n```vue [Child2.vue]\n<template>\n  <input v-model=\"r$.$value.email\" placeholder=\"Type your email\" />\n  <ul>\n    <li v-for=\"error of r$.$errors.email\" :key=\"error\">\n      {{ error }}\n    </li>\n  </ul>\n</template>\n\n```\n:::\n\nResult:\n\n## Multiple scopes\n\nIf you want to create your own separated scope, you can use `createScopedUseRegle` helper method.\n\nIt's advised to change the name of this composable to avoid conflicts or issues.\n\n```ts [scoped-config.ts]\nimport { createScopedUseRegle } from '@regle/core';\n\nexport const { useScopedRegle, useCollectScope } = createScopedUseRegle();\nexport const { \n  useScopedRegle: useContactsRegle, \n  useCollectScope: useCollectContacts \n} = createScopedUseRegle();\n```\n\n## Namespaces inside scopes\n\nEach scope can collect a specific namespace. Giving a namespace name will collect only the children with the same namespace name.\n\nThe namespace can be reactive, so it will update every time it changes.\n\nIn this example, only the components using the same scope and namespace will be collected.\n\n:::code-group\n```vue [Parent.vue]\n\n```\n\n```vue [Child1.vue]\n<template>\n  <input v-model=\"r$.$value.firstName\" placeholder=\"Type your firstname\" />\n  <ul>\n    <li v-for=\"error of r$.$errors.firstName\" :key=\"error\">\n      {{ error }}\n    </li>\n  </ul>\n</template>\n\n```\n\n```vue [Child2.vue]\n<template>\n  <input v-model=\"r$.$value.email\" placeholder=\"Type your email\" />\n  <ul>\n    <li v-for=\"error of r$.$errors.email\" :key=\"error\">\n      {{ error }}\n    </li>\n  </ul>\n</template>\n\n```\n\nYou can also collect multiple namespaces at once by passing an array of namespace names to the `useCollectScope` function.\n\n```ts\nconst { r$ } = useCollectScope(['contacts', 'persons']);\n```\n:::\n\n## Inject global config\n\nIf you have a global config already registered, simply pass it as a parameter to your `createScopedUseRegle` function.\n\n```ts twoslash [scoped-config.ts]\nimport { createScopedUseRegle, defineRegleConfig } from '@regle/core';\nimport { required, withMessage } from '@regle/rules';\n\nconst { useRegle } = defineRegleConfig({\n  rules: () => ({\n    custom: withMessage(required, 'Custom error'),\n  }),\n});\n\nexport const { useScopedRegle, useCollectScope } = createScopedUseRegle({customUseRegle: useRegle});\n\nconst {r$} = useScopedRegle({name: ''}, {\n  name: {\n    cus\n\n  }\n})\n\n```\n\n## Custom store for instances\n\nBy default collected instances are stored in a local ref. \n\nYou can provide your own store ref.\n\n```ts\nimport { createScopedUseRegle, type ScopedInstancesRecordLike } from '@regle/core';\n\n// Having a default \nconst myCustomStore = ref<ScopedInstancesRecordLike>({});\n\nconst { useScopedRegle, useCollectScope } = createScopedUseRegle({customStore: myCustomStore});\n```\n\n## Collect instances in a Record\n\nBy default collected instances are stored in a readonly array.\n\nIf you want to store your nested instances in a record it's possible with the `asRecord` option.\n\nThis will **require** every nested `useScopeRegle` to provide a parameter `id`.\n\n:::code-group\n\n```ts [scoped-config.ts]\nimport { createScopedUseRegle } from '@regle/core';\n\nexport const { \n  useScopedRegle: useScopedRegleItem, \n  useCollectScope: useCollectScopeRecord \n} = createScopedUseRegle({ asRecord: true });\n```\n```vue [Parent.vue]\n\n```\n\n```vue [Child1.vue]\n<template>\n  <input v-model=\"r$.$value.firstName\" placeholder=\"Type your firstname\" />\n  <ul>\n    <li v-for=\"error of r$.$errors.firstName\" :key=\"error\">\n      {{ error }}\n    </li>\n  </ul>\n</template>\n\n```\n\n```vue [Child2.vue]\n<template>\n  <input v-model=\"r$.$value.email\" placeholder=\"Type your email\" />\n  <ul>\n    <li v-for=\"error of r$.$errors.email\" :key=\"error\">\n      {{ error }}\n    </li>\n  </ul>\n</template>\n\n```\n:::\n\n## Manually dispose or register a scope entry\n\n`useScopedRegle` also returns two methods: `dispose` and `register`.\n\nYou can then programmatically handle if your component is collected from inside.\n\n```vue\n\n```\n\n## Manual typing\n\n:::warning\nUse with care, only if you're 100% sure of what return type your collected types will have.\n\nThe order of the collected values can change depending on if they added/deleted.\nThis is here for convenience but not advised.\n:::\n\n```ts twoslash\nimport { useCollectScope } from '@regle/core';\n\nconst { r$ } = useCollectScope<[{ foo: string }]>();\n\nconst { valid, data } = await r$.$validate();\n\n```\n\n## Testing\n\nIf you write unit test for a component using scoped validation, you may encounter problems with the tests failing.\n\nTo solve this, mount your component with the `attachTo` option set to the document element.\n\n```ts\nimport { mount } from '@vue/test-utils';\nimport ComponentUsingCollectScope from './ComponentUsingCollectScope.vue';\n\nconst wrapper = mount(ComponentUsingCollectScope, {\n  attachTo: document.documentElement,\n});\n```"
 		},
+		{
+			"id": "advanced-usage-self-validation",
+			"title": "Object self validation",
+			"category": "advanced-usage",
+			"path": "advanced-usage/self-validation.md",
+			"content": "# Object self validation\n\nBy default, Regle validates the nested properties of an object. But sometimes you need to validate the object itself, to perform cross-field validation that depends on multiple properties.\n\nThe `$self` property allows you to apply validation rules directly to an object, giving you full control over object-level validation.\n\n## Basic usage\n\nUse `$self` to define rules that validate the object itself rather than its nested properties.\n\n```ts twoslash\nimport { ref } from 'vue';\nimport { useRegle, type Maybe } from '@regle/core';\nimport { required, isFilled, minLength, withMessage } from '@regle/rules';\n\ntype User = {\n  firstName: string;\n  lastName: string;\n};\n\nconst state = ref<{ user: User }>({\n  user: {\n    firstName: '',\n    lastName: '',\n  },\n});\n\nconst { r$ } = useRegle(state, {\n  user: {\n    $self: {\n      // Custom rule: at least one name must be filled\n      atLeastOneName: withMessage(\n        (value: Maybe<User>) => isFilled(value?.firstName) || isFilled(value?.lastName),\n        'At least one name is required'\n      ),\n    },\n    firstName: { minLength: minLength(3) },\n    lastName: { minLength: minLength(3) },\n  },\n});\n```\n\nIn this example the `atLeastOneName` custom rule validates that at least one of `firstName` or `lastName` is filled.\n\n## Accessing `$self` status\n\nThe `$self` status is accessible through `r$.fieldName.$self` and provides all standard field status properties:\n\n```vue\n<template>\n  <ul>\n    <li v-for=\"error of r$.$errors.user.$self\" :key=\"error\">\n      {{ error }}\n    </li>\n  </ul>\n</template>\n```\nResult:"
+		},
 		{
 			"id": "advanced-usage-variants",
 			"title": "Variants",
@@ -132,7 +139,7 @@ var docs_data_default = {
 			"title": "Built-in rules",
 			"category": "rules",
 			"path": "core-concepts/rules/built-in-rules.md",
-			"content": "# Built-in rules\n\nAll built-in rules are available through the `@regle/rules` package.\n\nDon't forget to install it if you haven't:\n\n::: code-group\n\n```sh [pnpm]\npnpm add @regle/rules\n```\n\n```sh [npm]\nnpm install @regle/rules\n```\n\n```sh [yarn]\nyarn add @regle/rules\n```\n\n```sh [bun]\nbun add @regle/rules\n```\n\n:::\n\n:::tip\nEvery built-in rule will check if the value of the field is set before checking if it's valid.\n\nThis allow to have rules even if the field is not required.\n:::\n\n## `alpha`\n\n_**Params**_\n  - `allowSymbols?: MaybeRefOrGetter<boolean>`\n\nAllows only alphabetic characters.\n\n```ts\nimport { alpha } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: { \n    alpha,\n    // or\n    alpha: alpha({ allowSymbols: true }),\n  },\n})\n```\n\n## `alphaNum`\n\n_**Params**_\n  - `allowSymbols?: MaybeRefOrGetter<boolean>`\n\nAllows only alphanumeric characters.\n\n```ts\nimport { alphaNum } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: { \n    alphaNum,\n    // or\n    alphaNum: alphaNum({ allowSymbols: true }),\n})\n```\n\n## `between`\n\n_**Params**_\n  - `min: Ref<number> | number | () => number`\n  - `max: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\nChecks if a number is in specified bounds. `min` and `max` are both inclusive.\n\n```ts\nimport { between } from '@regle/rules';\n\nconst maxCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    between: between(1, 6),\n    between: between(1, maxCount, {allowEqual: false}),\n    between: between(() => maxCount.value, 10)\n  },\n})\n```\n\n## `boolean`\n\nRequires a value to be a native boolean type. Mainly used for typing.\n\n```ts\nimport {type InferInput} from '@regle/core';\nimport { boolean } from '@regle/rules';\n\nconst rules = {\n  checkbox: { boolean },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `checked`\n\nRequires a boolean value to be `true`. This is useful for checkbox inputs.\n\n```ts\nimport { checked } from '@regle/rules';\n\nconst { r$ } = useRegle({ confirm: false }, {\n  confirm: { checked },\n})\n```\n\n## `contains`\n\n_**Params**_\n- `contain: Ref<string> | string | () => string`\n\nChecks if the string contains the specified substring.\n\n```ts\nimport { contains } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestLib: '' }, {\n  bestLib: {\n    contains: contains('regle')\n  },\n})\n```\n\n## `date`\n\nRequires a value to be a native Date constructor. Mainly used for typing.\n\n```ts\nimport {type InferInput} from '@regle/core';\nimport { date } from '@regle/rules';\n\nconst rules = {\n  birthday: { date },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `dateAfter`\n_**Params**_\n - `after: Ref<string | Date> | string | Date | () => string | Date`\n - `options?: {allowEqual?: boolean}`\n\nChecks if the date is after the given parameter.\n\n```ts\nimport { dateAfter } from '@regle/rules';\n\nconst today = ref(new Date());\n\nconst { r$ } = useRegle({ birthday: null as Date | null }, {\n  birthday: {\n    dateAfter: dateAfter(today),\n    // or\n    dateAfter: dateAfter(today, { allowEqual: false }),\n  },\n})\n```\n\n## `dateBefore`\n_**Params**_\n - `before: Ref<string | Date> | string | Date | () => string | Date`\n - `options?: {allowEqual?: boolean}`\n\nChecks if the date is before the given parameter.\n\n```ts\nimport { dateBefore } from '@regle/rules';\n\nconst today = ref(new Date());\n\nconst { r$ } = useRegle({ birthday: null as Date | null }, {\n  birthday: {\n    dateBefore: dateBefore(today),\n    // or\n    dateBefore: dateBefore(today, { allowEqual: false }),\n  },\n})\n```\n\n## `dateBetweeen`\n\n_**Params**_\n - `before: Ref<string | Date> | string | Date | () => string | Date`\n - `after: Ref<string | Date> | string | Date | () => string | Date`\n - `options?: {allowEqual?: boolean}`\n\nChecks if the date falls between the specified bounds.\n\n```ts\nimport { dateBetween } from '@regle/rules';\n\nconst before = ref(new Date());\nconst after = ref(new Date(2030, 3, 1));\n\nconst { r$ } = useRegle({ birthday: null as Date | null }, {\n  birthday: {\n    dateBetween: dateBetween(before, after),\n    // or\n    dateBetween: dateBetween(before, after, { allowEqual: false }),\n  },\n})\n```\n\n## `decimal`\n\nAllows positive and negative decimal numbers.\n\n```ts\nimport { decimal } from '@regle/rules';\n\nconst { r$ } = useRegle({ price: 0 }, {\n  price: { decimal },\n})\n```\n\n## `email`\n\nValidates email addresses. Always verify on the server to ensure the address is real and not already in use.\n\n```ts\nimport { email } from '@regle/rules';\n\nconst { r$ } = useRegle({ email: '' }, {\n  email: { email },\n})\n```\n\n## `emoji`\n\nValidates emojis.\n\n```ts\nimport { emoji } from '@regle/rules';\n\nconst { r$ } = useRegle({ emoji: '' }, {\n  emoji: { emoji },\n})\n```\n\n## `endsWith`\n\n_**Params**_\n- `end: Ref<string> | string | () => string`\n\nChecks if the string ends with the specified substring.\n\n```ts\nimport { endsWith } from '@regle/rules';\n\nconst { r$ } = useRegle({ firstName: '' }, {\n  firstName: { endsWith: endsWith('foo') },\n})\n```\n\n## `exactDigits`\n_**Params**_\n  - `count: Ref<number> | number | () => number`\n\nRequires the input value to have a strict specified number of digits.\n\n```ts\nimport { exactDigits } from '@regle/rules';\n\nconst exactValue = ref(6);\n\nconst { r$ } = useRegle({ digits: '' }, {\n  digits: {\n    exactDigits: exactDigits(6),\n    // or with ref\n    exactDigits: exactDigits(exactValue),\n    // or with getter\n    exactDigits: exactDigits(() => exactValue.value)\n  },\n})\n```\n\n## `exactLength`\n\n_**Params**_\n  - `count: Ref<number> | number | () => number`\n\nRequires the input value to have a strict specified length, inclusive. Works with arrays, objects and strings.\n\n```ts\nimport { exactLength } from '@regle/rules';\n\nconst exactValue = ref(6);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    exactLength: exactLength(6),\n    exactLength: exactLength(exactValue),\n    exactLength: exactLength(() => exactValue.value)\n  },\n})\n```\n\n## `exactValue`\n\n_**Params**_\n  - `count: Ref<number> | number | () => number`\n\nRequires a field to have a strict numeric value.\n\n```ts\nimport { exactValue } from '@regle/rules';\n\nconst exactCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    exactValue: exactValue(6),\n    exactValue: exactValue(exactCount),\n    exactValue: exactValue(() => exactCount.value)\n  },\n})\n```\n\n## `file`\n\nRequires a value to be a native File constructor. Mainly used for typing.\n\n```ts\nimport { file } from '@regle/rules';\n\nconst rules = {\n  file: { file },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `fileType`\n\nRequires a value to be a file with a specific type.\n\n```ts\nimport { fileType } from '@regle/rules';\n\nconst { r$ } = useRegle({ file: null as File | null }, {\n  file: { fileType: fileType(['image/png', 'image/jpeg']) },\n})\n```\n\n## `hexadecimal`\n\nValidates hexadecimal values.\n\n```ts\nimport { hexadecimal } from '@regle/rules';\n\nconst { r$ } = useRegle({ hexadecimal: '' }, {\n  hexadecimal: { hexadecimal },\n})\n```\n\n## `hostname`\n\nValidates hostnames.\n\n```ts\nimport { hostname } from '@regle/rules';\n\nconst { r$ } = useRegle({ siteHost: '' }, {\n  siteHost: { hostname },\n})\n```\n\n## `httpUrl`\n\n_**Params**_\n- `options?: {protocol?: RegExp}`\n\nValidates HTTP URLs.\n\n```ts\nimport { httpUrl } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestUrl: '' }, {\n  bestUrl: { httpUrl },\n  // or with custom protocol validation\n  bestUrl: { httpUrl: httpUrl({ protocol: /^https$/ }) },\n})\n```\n\n## `integer`\n\nAllows only integers (positive and negative).\n\n```ts\nimport { integer } from '@regle/rules';\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: { integer },\n})\n```\n\n## `ipv4Address`\n\nValidates IPv4 addresses in dotted decimal notation *127.0.0.1*.\n\n```ts\nimport { ipv4Address } from '@regle/rules';\n\nconst { r$ } = useRegle({ address: '' }, {\n  address: { ipv4Address },\n})\n```\n\n## `literal`\n\nValidates literal values.\n\n```ts\nimport { literal } from '@regle/rules';\n\nconst { r$ } = useRegle({ value: '' }, {\n  value: { literal: literal('foo') },\n})\n```\n\n## `lowercase`\n\nValidates lowercase strings.\n\n```ts\nimport { lowercase } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: { lowercase },\n})\n```\n\n## `macAddress`\n\n_**Params**_\n  - `separator?: string | Ref<string> | () => string`\n\nValidates MAC addresses. Call as a function to specify a custom separator (e.g., ':' or an empty string for 00ff1122334455).\n\n```ts\n\nimport { macAddress } from '@regle/rules';\n\nconst maxCount = ref(6);\n\nconst { r$ } = useRegle({ address: '' }, {\n  address: {\n    macAddress,\n    // or\n    macAddress: macAddress('-')\n  },\n})\n```\n\n## `maxFileSize`\n\nRequires a value to be a file with a maximum size.\n\n```ts\nimport { maxFileSize } from '@regle/rules';\n\nconst { r$ } = useRegle({ file: null as File | null }, {\n  file: { maxFileSize: maxFileSize(10_000_000) }, // 10 MB\n})\n```\n\n## `maxLength`\n\n_**Params**_\n  - `max: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\n_**Works with**_\n  - `Array | Record | string | number`\n\nRequires the input value to have a maximum specified length, inclusive. Works with arrays, objects and strings.\n\n```ts\nimport { maxLength } from '@regle/rules';\n\nconst maxValue = ref(6);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    maxLength: maxLength(6),\n    maxLength: maxLength(maxValue),\n    maxLength: maxLength(() => maxValue.value)\n  },\n})\n```\n\n## `maxValue`\n\n_**Params**_\n  - `min: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\n  Requires a field to have a specified maximum numeric value.\n\n```ts\nimport { maxValue } from '@regle/rules';\n\nconst maxCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    maxValue: maxValue(6),\n    maxValue: maxValue(maxCount, {allowEqual: false}),\n    maxValue: maxValue(() => maxCount.value)\n  },\n})\n```\n\n## `minFileSize`\n\nRequires a value to be a file with a minimum size.\n\n```ts\nimport { minFileSize } from '@regle/rules';\n\nconst { r$ } = useRegle({ file: null as File | null }, {\n  file: { minFileSize: minFileSize(1_000_000) }, // 1 MB\n})\n```\n\n## `minLength`\n\n_**Params**_\n  - `min: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\n_**Works with**_\n  - `Array | Record | string | number`\n\nRequires the input value to have a minimum specified length, inclusive. Works with arrays, objects and strings.\n\n```ts\nimport { minLength } from '@regle/rules';\n\nconst minValue = ref(6);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    minLength: minLength(6),\n    minLength: minLength(minValue),\n    minLength: minLength(() => minValue.value)\n  },\n})\n```\n\n## `minValue`\n\n_**Params**_\n  - `min: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\n_**Works with**_\n  - `number`\n\nRequires a field to have a specified minimum numeric value.\n\n```ts\nimport { minValue } from '@regle/rules';\n\nconst minCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    minValue: minValue(6),\n    minValue: minValue(minCount, {allowEqual: false}),\n    minValue: minValue(() => minCount.value)\n  },\n})\n```\n\n## `nativeEnum`\n\nValidate against a native Typescript enum value. Similar to Zod's `nativeEnum`\n\n```ts\nimport { nativeEnum } from '@regle/rules';\n\nenum Foo {\n  Bar, Baz\n}\n\nconst { r$ } = useRegle({ type: '' }, {\n  type: { nativeEnum: nativeEnum(Foo) },\n})\n```\n\n## `number`\n\nRequires a value to be a native number type. Mainly used for typing.\n\n```ts\nimport { number } from '@regle/rules';\n\nconst rules = {\n  count: { number },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `numeric`\n\nAllows only numeric values (including numeric strings).\n\n```ts\nimport { numeric } from '@regle/rules';\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: { numeric },\n})\n```\n\n## `oneOf`\n\nAllow only one of the values from a fixed Array of possible entries.\n\n_**Params**_\n  - `options: MaybeRefOrGetter<Array<string | number>>`\n\n```ts\nimport { oneOf } from '@regle/rules';\n\nconst { r$ } = useRegle({ aliment: 'Fish' }, {\n  aliment: {\n    oneOf: oneOf(['Fish', 'Meat', 'Bone'])\n  },\n})\n```\n\n## `regex`\n\n_**Params**_\n- `regexps: MaybeRefOrGetter<RegExp | RegExp[]>`\n\nChecks if the value matches one or more regular expressions.\n\n```ts\nimport { regex } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    regex: regex(/^foo/),\n    regex: regex([/^bar/, /baz$/]),\n  },\n})\n```\n\n## `required`\n\nRequires non-empty data. Checks for empty arrays and strings containing only whitespaces.\n\n```ts\nimport {required} from '@regle/rules';\n\nconst {r$} = useRegle({name: ''}, {\n  name: {required},\n})\n```\n\n## `requiredIf`\n\n_**Params**_\n  - `condition: Ref<unknown> | unknown | () => unknown` - the property to base the `required` validator on.\n\nRequires non-empty data, only if provided data property, ref, or a function resolves to `true`.\n\n```ts\nimport { requiredIf } from '@regle/rules';\n\nconst form = ref({ name: '', condition: false });\n\nconst conditionRef = ref(false);\n\nconst { r$ } = useRegle(form, {\n  name: {\n    required: requiredIf(() => form.value.condition),\n    required: requiredIf(conditionRef),\n  },\n})\n```\n\n## `requiredUnless`\n\n_**Params**_\n  - `condition: Ref<unknown> | unknown | () => unknown` - the property to base the `required` validator on.\n\nRequires non-empty data, only if provided data property, ref, or a function resolves to `false`.\n\n```ts\nimport { requiredUnless } from '@regle/rules';\n\nconst form = ref({ name: '', condition: false });\n\nconst conditionRef = ref(false);\n\nconst { r$ } = useRegle(form, {\n  name: {\n    required: requiredUnless(() => form.value.condition),\n    required: requiredUnless(conditionRef)\n  },\n})\n```\n\n## `sameAs`\n\n_**Params**_\n  * `target: unknown`\n\nChecks if the value matches the specified property or ref.\n\n```ts\nimport { sameAs } from '@regle/rules';\n\nconst form = ref({\n  password: '',\n  confirmPassword: '',\n});\n\nconst { r$ } = useRegle(form, {\n  confirmPassword: {\n    sameAs: sameAs(() => form.value.password),\n  }\n})\n```\n\n## `startsWith`\n\n_**Params**_\n- `start: Ref<string> | string | () => string`\n\nChecks if the string starts with the specified substring.\n\n```ts\nimport { startsWith } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestLib: '' }, {\n  bestLib: {\n    startsWith: startsWith('regle')\n  },\n})\n```\n\n## `string`\n\nRequires a value to be a native string type. Mainly used for typing\n\n```ts\nimport {type InferInput} from '@regle/core';\nimport { string } from '@regle/rules';\n\nconst rules = {\n  firstName: { string },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `type`\n\nDefine the input type of a rule. No runtime validation.   \nOverride any input type set by other rules.\n\n```ts\nimport {type InferInput} from '@regle/core';\nimport { type } from '@regle/rules';\n\nconst rules = {\n  firstName: { type: type<string>() },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `uppercase`\n\nValidates uppercase strings.\n\n```ts\nimport { uppercase } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: { uppercase },\n})\n```\n\n## `url`\n\n_**Params**_\n- `options?: {protocol?: RegExp}`\n\nValidates URLs.\n\n```ts\nimport { url } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestUrl: '' }, {\n  bestUrl: { url },\n  // or with custom protocol validation\n  bestUrl: { url: url({ protocol: /^https?$/ }) },\n})\n```"
+			"content": "# Built-in rules\n\nAll built-in rules are available through the `@regle/rules` package.\n\nDon't forget to install it if you haven't:\n\n::: code-group\n\n```sh [pnpm]\npnpm add @regle/rules\n```\n\n```sh [npm]\nnpm install @regle/rules\n```\n\n```sh [yarn]\nyarn add @regle/rules\n```\n\n```sh [bun]\nbun add @regle/rules\n```\n\n:::\n\n:::tip\nEvery built-in rule will check if the value of the field is set before checking if it's valid.\n\nThis allow to have rules even if the field is not required.\n:::\n\n## `alpha`\n\n_**Params**_\n  - `allowSymbols?: MaybeRefOrGetter<boolean>`\n\nAllows only alphabetic characters.\n\n```ts\nimport { alpha } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: { \n    alpha,\n    // or\n    alpha: alpha({ allowSymbols: true }),\n  },\n})\n```\n\n## `alphaNum`\n\n_**Params**_\n  - `allowSymbols?: MaybeRefOrGetter<boolean>`\n\nAllows only alphanumeric characters.\n\n```ts\nimport { alphaNum } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: { \n    alphaNum,\n    // or\n    alphaNum: alphaNum({ allowSymbols: true }),\n})\n```\n\n## `atLeastOne`\n\n_**Params**_\n  - `keys?: MaybeRefOrGetter<string[]>` - Optional list of keys to check. If not provided, checks if the object has at least one filled property.\n\n_**Works with**_\n  - `Record | object`\n\nChecks if at least one key is filled in the object. Useful for object-level validation with `$self`.\n\n```ts\nimport { atLeastOne } from '@regle/rules';\n\nconst { r$ } = useRegle({ user: { firstName: '', lastName: '' } }, {\n  user: {\n    $self: {\n      // Check if any property is filled\n      atLeastOne,\n      // or check specific keys\n      atLeastOne: atLeastOne(['firstName', 'lastName']),\n    },\n  },\n})\n```\n\n## `between`\n\n_**Params**_\n  - `min: Ref<number> | number | () => number`\n  - `max: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\nChecks if a number is in specified bounds. `min` and `max` are both inclusive.\n\n```ts\nimport { between } from '@regle/rules';\n\nconst maxCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    between: between(1, 6),\n    between: between(1, maxCount, {allowEqual: false}),\n    between: between(() => maxCount.value, 10)\n  },\n})\n```\n\n## `boolean`\n\nRequires a value to be a native boolean type. Mainly used for typing.\n\n```ts\nimport {type InferInput} from '@regle/core';\nimport { boolean } from '@regle/rules';\n\nconst rules = {\n  checkbox: { boolean },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `checked`\n\nRequires a boolean value to be `true`. This is useful for checkbox inputs.\n\n### Note\n\nThis rule does not need `required` to be set, it will assert the value is set.\n\n```ts\nimport { checked } from '@regle/rules';\n\nconst { r$ } = useRegle({ confirm: false }, {\n  confirm: { checked },\n})\n```\n\n## `contains`\n\n_**Params**_\n- `contain: Ref<string> | string | () => string`\n\nChecks if the string contains the specified substring.\n\n```ts\nimport { contains } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestLib: '' }, {\n  bestLib: {\n    contains: contains('regle')\n  },\n})\n```\n\n## `date`\n\nRequires a value to be a native Date constructor. Mainly used for typing.\n\n```ts\nimport {type InferInput} from '@regle/core';\nimport { date } from '@regle/rules';\n\nconst rules = {\n  birthday: { date },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `dateAfter`\n_**Params**_\n - `after: Ref<string | Date> | string | Date | () => string | Date`\n - `options?: {allowEqual?: boolean}`\n\nChecks if the date is after the given parameter.\n\n```ts\nimport { dateAfter } from '@regle/rules';\n\nconst today = ref(new Date());\n\nconst { r$ } = useRegle({ birthday: null as Date | null }, {\n  birthday: {\n    dateAfter: dateAfter(today),\n    // or\n    dateAfter: dateAfter(today, { allowEqual: false }),\n  },\n})\n```\n\n## `dateBefore`\n_**Params**_\n - `before: Ref<string | Date> | string | Date | () => string | Date`\n - `options?: {allowEqual?: boolean}`\n\nChecks if the date is before the given parameter.\n\n```ts\nimport { dateBefore } from '@regle/rules';\n\nconst today = ref(new Date());\n\nconst { r$ } = useRegle({ birthday: null as Date | null }, {\n  birthday: {\n    dateBefore: dateBefore(today),\n    // or\n    dateBefore: dateBefore(today, { allowEqual: false }),\n  },\n})\n```\n\n## `dateBetweeen`\n\n_**Params**_\n - `before: Ref<string | Date> | string | Date | () => string | Date`\n - `after: Ref<string | Date> | string | Date | () => string | Date`\n - `options?: {allowEqual?: boolean}`\n\nChecks if the date falls between the specified bounds.\n\n```ts\nimport { dateBetween } from '@regle/rules';\n\nconst before = ref(new Date());\nconst after = ref(new Date(2030, 3, 1));\n\nconst { r$ } = useRegle({ birthday: null as Date | null }, {\n  birthday: {\n    dateBetween: dateBetween(before, after),\n    // or\n    dateBetween: dateBetween(before, after, { allowEqual: false }),\n  },\n})\n```\n\n## `decimal`\n\nAllows positive and negative decimal numbers.\n\n```ts\nimport { decimal } from '@regle/rules';\n\nconst { r$ } = useRegle({ price: 0 }, {\n  price: { decimal },\n})\n```\n\n## `email`\n\nValidates email addresses. Always verify on the server to ensure the address is real and not already in use.\n\n```ts\nimport { email } from '@regle/rules';\n\nconst { r$ } = useRegle({ email: '' }, {\n  email: { email },\n})\n```\n\n## `emoji`\n\nValidates emojis.\n\n```ts\nimport { emoji } from '@regle/rules';\n\nconst { r$ } = useRegle({ emoji: '' }, {\n  emoji: { emoji },\n})\n```\n\n## `endsWith`\n\n_**Params**_\n- `end: Ref<string> | string | () => string`\n\nChecks if the string ends with the specified substring.\n\n```ts\nimport { endsWith } from '@regle/rules';\n\nconst { r$ } = useRegle({ firstName: '' }, {\n  firstName: { endsWith: endsWith('foo') },\n})\n```\n\n## `exactDigits`\n_**Params**_\n  - `count: Ref<number> | number | () => number`\n\nRequires the input value to have a strict specified number of digits.\n\n```ts\nimport { exactDigits } from '@regle/rules';\n\nconst exactValue = ref(6);\n\nconst { r$ } = useRegle({ digits: '' }, {\n  digits: {\n    exactDigits: exactDigits(6),\n    // or with ref\n    exactDigits: exactDigits(exactValue),\n    // or with getter\n    exactDigits: exactDigits(() => exactValue.value)\n  },\n})\n```\n\n## `exactLength`\n\n_**Params**_\n  - `count: Ref<number> | number | () => number`\n\nRequires the input value to have a strict specified length, inclusive. Works with arrays, objects and strings.\n\n```ts\nimport { exactLength } from '@regle/rules';\n\nconst exactValue = ref(6);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    exactLength: exactLength(6),\n    exactLength: exactLength(exactValue),\n    exactLength: exactLength(() => exactValue.value)\n  },\n})\n```\n\n## `exactValue`\n\n_**Params**_\n  - `count: Ref<number> | number | () => number`\n\nRequires a field to have a strict numeric value.\n\n```ts\nimport { exactValue } from '@regle/rules';\n\nconst exactCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    exactValue: exactValue(6),\n    exactValue: exactValue(exactCount),\n    exactValue: exactValue(() => exactCount.value)\n  },\n})\n```\n\n## `file`\n\nRequires a value to be a native File constructor. Mainly used for typing.\n\n```ts\nimport { file } from '@regle/rules';\n\nconst rules = {\n  file: { file },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `fileType`\n\nRequires a value to be a file with a specific type.\n\n```ts\nimport { fileType } from '@regle/rules';\n\nconst { r$ } = useRegle({ file: null as File | null }, {\n  file: { fileType: fileType(['image/png', 'image/jpeg']) },\n})\n```\n\n## `hexadecimal`\n\nValidates hexadecimal values.\n\n```ts\nimport { hexadecimal } from '@regle/rules';\n\nconst { r$ } = useRegle({ hexadecimal: '' }, {\n  hexadecimal: { hexadecimal },\n})\n```\n\n## `hostname`\n\nValidates hostnames.\n\n```ts\nimport { hostname } from '@regle/rules';\n\nconst { r$ } = useRegle({ siteHost: '' }, {\n  siteHost: { hostname },\n})\n```\n\n## `httpUrl`\n\n_**Params**_\n- `options?: {protocol?: RegExp}`\n\nValidates HTTP URLs.\n\n```ts\nimport { httpUrl } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestUrl: '' }, {\n  bestUrl: { httpUrl },\n  // or with custom protocol validation\n  bestUrl: { httpUrl: httpUrl({ protocol: /^https$/ }) },\n})\n```\n\n## `integer`\n\nAllows only integers (positive and negative).\n\n```ts\nimport { integer } from '@regle/rules';\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: { integer },\n})\n```\n\n## `ipv4Address`\n\nValidates IPv4 addresses in dotted decimal notation *127.0.0.1*.\n\n```ts\nimport { ipv4Address } from '@regle/rules';\n\nconst { r$ } = useRegle({ address: '' }, {\n  address: { ipv4Address },\n})\n```\n\n## `literal`\n\nValidates literal values.\n\n### Note\n\nThis rule does not need `required` to be set, it will assert the value is set.\n\n```ts\nimport { literal } from '@regle/rules';\n\nconst { r$ } = useRegle({ value: '' }, {\n  value: { literal: literal('foo') },\n})\n```\n\n## `lowercase`\n\nValidates lowercase strings.\n\n```ts\nimport { lowercase } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: { lowercase },\n})\n```\n\n## `macAddress`\n\n_**Params**_\n  - `separator?: string | Ref<string> | () => string`\n\nValidates MAC addresses. Call as a function to specify a custom separator (e.g., ':' or an empty string for 00ff1122334455).\n\n```ts\n\nimport { macAddress } from '@regle/rules';\n\nconst maxCount = ref(6);\n\nconst { r$ } = useRegle({ address: '' }, {\n  address: {\n    macAddress,\n    // or\n    macAddress: macAddress('-')\n  },\n})\n```\n\n## `maxFileSize`\n\nRequires a value to be a file with a maximum size.\n\n```ts\nimport { maxFileSize } from '@regle/rules';\n\nconst { r$ } = useRegle({ file: null as File | null }, {\n  file: { maxFileSize: maxFileSize(10_000_000) }, // 10 MB\n})\n```\n\n## `maxLength`\n\n_**Params**_\n  - `max: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\n_**Works with**_\n  - `Array | Record | string | number`\n\nRequires the input value to have a maximum specified length, inclusive. Works with arrays, objects and strings.\n\n```ts\nimport { maxLength } from '@regle/rules';\n\nconst maxValue = ref(6);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    maxLength: maxLength(6),\n    maxLength: maxLength(maxValue),\n    maxLength: maxLength(() => maxValue.value)\n  },\n})\n```\n\n## `maxValue`\n\n_**Params**_\n  - `min: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\n  Requires a field to have a specified maximum numeric value.\n\n```ts\nimport { maxValue } from '@regle/rules';\n\nconst maxCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    maxValue: maxValue(6),\n    maxValue: maxValue(maxCount, {allowEqual: false}),\n    maxValue: maxValue(() => maxCount.value)\n  },\n})\n```\n\n## `minFileSize`\n\nRequires a value to be a file with a minimum size.\n\n```ts\nimport { minFileSize } from '@regle/rules';\n\nconst { r$ } = useRegle({ file: null as File | null }, {\n  file: { minFileSize: minFileSize(1_000_000) }, // 1 MB\n})\n```\n\n## `minLength`\n\n_**Params**_\n  - `min: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\n_**Works with**_\n  - `Array | Record | string | number`\n\nRequires the input value to have a minimum specified length, inclusive. Works with arrays, objects and strings.\n\n```ts\nimport { minLength } from '@regle/rules';\n\nconst minValue = ref(6);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    minLength: minLength(6),\n    minLength: minLength(minValue),\n    minLength: minLength(() => minValue.value)\n  },\n})\n```\n\n## `minValue`\n\n_**Params**_\n  - `min: Ref<number> | number | () => number`\n  - `options?: {allowEqual?: boolean}`\n\n_**Works with**_\n  - `number`\n\nRequires a field to have a specified minimum numeric value.\n\n```ts\nimport { minValue } from '@regle/rules';\n\nconst minCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    minValue: minValue(6),\n    minValue: minValue(minCount, {allowEqual: false}),\n    minValue: minValue(() => minCount.value)\n  },\n})\n```\n\n## `nativeEnum`\n\nValidate against a native Typescript enum value. Similar to Zod's `nativeEnum`\n\n```ts\nimport { nativeEnum } from '@regle/rules';\n\nenum Foo {\n  Bar, Baz\n}\n\nconst { r$ } = useRegle({ type: '' }, {\n  type: { nativeEnum: nativeEnum(Foo) },\n})\n```\n\n## `number`\n\nRequires a value to be a native number type. Mainly used for typing.\n\n```ts\nimport { number } from '@regle/rules';\n\nconst rules = {\n  count: { number },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `numeric`\n\nAllows only numeric values (including numeric strings).\n\n```ts\nimport { numeric } from '@regle/rules';\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: { numeric },\n})\n```\n\n## `oneOf`\n\nAllow only one of the values from a fixed Array of possible entries.\n\n_**Params**_\n  - `options: MaybeRefOrGetter<Array<string | number>>`\n\n```ts\nimport { oneOf } from '@regle/rules';\n\nconst { r$ } = useRegle({ aliment: 'Fish' }, {\n  aliment: {\n    oneOf: oneOf(['Fish', 'Meat', 'Bone'])\n  },\n})\n```\n\n## `regex`\n\n_**Params**_\n- `regexps: MaybeRefOrGetter<RegExp | RegExp[]>`\n\nChecks if the value matches one or more regular expressions.\n\n```ts\nimport { regex } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    regex: regex(/^foo/),\n    regex: regex([/^bar/, /baz$/]),\n  },\n})\n```\n\n## `required`\n\nRequires non-empty data. Checks for empty arrays and strings containing only whitespaces.\n\n```ts\nimport {required} from '@regle/rules';\n\nconst {r$} = useRegle({name: ''}, {\n  name: {required},\n})\n```\n\n## `requiredIf`\n\n_**Params**_\n  - `condition: Ref<unknown> | unknown | () => unknown` - the property to base the `required` validator on.\n\nRequires non-empty data, only if provided data property, ref, or a function resolves to `true`.\n\n```ts\nimport { requiredIf } from '@regle/rules';\n\nconst form = ref({ name: '', condition: false });\n\nconst conditionRef = ref(false);\n\nconst { r$ } = useRegle(form, {\n  name: {\n    required: requiredIf(() => form.value.condition),\n    required: requiredIf(conditionRef),\n  },\n})\n```\n\n## `requiredUnless`\n\n_**Params**_\n  - `condition: Ref<unknown> | unknown | () => unknown` - the property to base the `required` validator on.\n\nRequires non-empty data, only if provided data property, ref, or a function resolves to `false`.\n\n```ts\nimport { requiredUnless } from '@regle/rules';\n\nconst form = ref({ name: '', condition: false });\n\nconst conditionRef = ref(false);\n\nconst { r$ } = useRegle(form, {\n  name: {\n    required: requiredUnless(() => form.value.condition),\n    required: requiredUnless(conditionRef)\n  },\n})\n```\n\n## `sameAs`\n\n_**Params**_\n  * `target: unknown`\n\nChecks if the value matches the specified property or ref.\n\n```ts\nimport { sameAs } from '@regle/rules';\n\nconst form = ref({\n  password: '',\n  confirmPassword: '',\n});\n\nconst { r$ } = useRegle(form, {\n  confirmPassword: {\n    sameAs: sameAs(() => form.value.password),\n  }\n})\n```\n\n## `startsWith`\n\n_**Params**_\n- `start: Ref<string> | string | () => string`\n\nChecks if the string starts with the specified substring.\n\n```ts\nimport { startsWith } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestLib: '' }, {\n  bestLib: {\n    startsWith: startsWith('regle')\n  },\n})\n```\n\n## `string`\n\nRequires a value to be a native string type. Mainly used for typing\n\n```ts\nimport {type InferInput} from '@regle/core';\nimport { string } from '@regle/rules';\n\nconst rules = {\n  firstName: { string },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `type`\n\nDefine the input type of a rule. No runtime validation.   \nOverride any input type set by other rules.\n\n```ts\nimport {type InferInput} from '@regle/core';\nimport { type } from '@regle/rules';\n\nconst rules = {\n  firstName: { type: type<string>() },\n}\n\nconst state = ref<InferInput<typeof rules>>({});\n```\n\n## `uppercase`\n\nValidates uppercase strings.\n\n```ts\nimport { uppercase } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: { uppercase },\n})\n```\n\n## `url`\n\n_**Params**_\n- `options?: {protocol?: RegExp}`\n\nValidates URLs.\n\n```ts\nimport { url } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestUrl: '' }, {\n  bestUrl: { url },\n  // or with custom protocol validation\n  bestUrl: { url: url({ protocol: /^https?$/ }) },\n})\n```"
 		},
 		{
 			"id": "core-concepts-rules-index",
@@ -160,7 +167,7 @@ var docs_data_default = {
 			"title": "Rules operators",
 			"category": "rules",
 			"path": "core-concepts/rules/rules-operators.md",
-			"content": "# Rules operators\n\nRegle provides tools to combine and operate on different rules. It includes four built-in operators, available in `@regle/rules`:\n\n- `and`\n- `or`\n- `not`\n- `applyIf`\n- `assignIf`\n\nThese operators work with any rules you provide, but combining rules with incompatible input types may lead to errors.\n\n:::tip\nAll operators are compatible with wrappers\n:::\n\n## `and`\n\nThe `and` operator combines multiple rules and validates successfully only if all provided rules are valid.\n\n```ts\nimport { useRegle } from '@regle/core';\nimport { and, startsWith, endsWith, withMessage } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { regex: '' },\n  {\n    regex: {\n      myError: withMessage(\n        and(startsWith('^'), endsWith('$')),\n        ({ $params: [start, end] }) =>\n          `Regex should start with \"${start}\" and end with \"${end}\"`\n      ),\n    },\n  }\n);\n```\n\nResult: \n\n## `or`\n\nThe `or` operator validates successfully if at least one of the provided rules is valid.\n\n```ts twoslash\nimport { useRegle } from '@regle/core';\nimport { or, startsWith, endsWith, withMessage } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { regex: '' },\n  {\n    regex: {\n      myError: withMessage(\n        or(startsWith('^'), endsWith('$')),\n        ({ $params: [start, end] }) =>\n          `Field should start with \"${start}\" or end with \"${end}\"`\n      ),\n    },\n  }\n);\n```\n\nResult: \n\n## `not`\n\nThe `not` operator passes when the provided rule fails and fails when the rule passes. It can be combined with other rules.\n\n```ts\nimport { useRegle } from '@regle/core';\nimport { not, required, sameAs, withMessage } from '@regle/rules';\nimport { ref } from 'vue';\n\nconst form = ref({ oldPassword: '', newPassword: '' });\nconst { r$ } = useRegle(form, {\n  oldPassword: {\n    required,\n  },\n  newPassword: {\n    notEqual: withMessage(\n      not(sameAs(() => form.value.oldPassword)),\n      'Your confirm new password must not be the same as your old password'\n    ),\n  },\n});\n```\n\nResult: \n\n## `applyIf`\n\nThe `applyIf` operator is similar to `requiredIf`, but it can be used with any rule. It simplifies conditional rule declarations.\n\n```ts\nimport { minLength, applyIf } from '@regle/rules';\n\nconst condition = ref(false);\n\nconst { r$ } = useRegle({name: ''}, {\n  name: {\n    minLength: applyIf(condition, minLength(6))\n  },\n});\n```\n\n## `assignIf`\n\nThe `assignIf` is a shorthand for conditional destructuring assignment.\nIt allows to apply multiple rules to a field conditionally.\n\n```ts\nimport { required, email, minLength, assignIf } from '@regle/rules';\n\nconst condition = ref(false);\n\nconst { r$ } = useRegle(ref({ name: '', email: '' }), {\n  name: assignIf(condition, { required, minLength: minLength(4) }),\n  email: { email },\n});\n```"
+			"content": "# Rules operators\n\nRegle provides tools to combine and operate on different rules. It includes the following built-in operators, available in `@regle/rules`:\n\n- `and`\n- `or`\n- `xor`\n- `not`\n- `applyIf`\n- `assignIf`\n- `pipe`\n\nThese operators work with any rules you provide, but combining rules with incompatible input types may lead to errors.\n\n:::tip\nAll operators are compatible with wrappers\n:::\n\n## `and`\n\nThe `and` operator combines multiple rules and validates successfully only if all provided rules are valid.\n\n```ts\nimport { useRegle } from '@regle/core';\nimport { and, startsWith, endsWith, withMessage } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { regex: '' },\n  {\n    regex: {\n      myError: withMessage(\n        and(startsWith('^'), endsWith('$')),\n        ({ $params: [start, end] }) =>\n          `Regex should start with \"${start}\" and end with \"${end}\"`\n      ),\n    },\n  }\n);\n```\n\nResult: \n\n## `or`\n\nThe `or` operator validates successfully if at least one of the provided rules is valid.\n\n```ts twoslash\nimport { useRegle } from '@regle/core';\nimport { or, startsWith, endsWith, withMessage } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { regex: '' },\n  {\n    regex: {\n      myError: withMessage(\n        or(startsWith('^'), endsWith('$')),\n        ({ $params: [start, end] }) =>\n          `Field should start with \"${start}\" or end with \"${end}\"`\n      ),\n    },\n  }\n);\n```\n\nResult: \n\n## `xor`\n\nThe `xor` operator (exclusive or) validates successfully if **exactly one** of the provided rules is valid. It fails when none or more than one rule passes.\n\n```ts\nimport { useRegle } from '@regle/core';\nimport { xor, contains, withMessage } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { code: '' },\n  {\n    code: {\n      myError: withMessage(\n        xor(contains('A'), contains('B')),\n        ({ $params: [charA, charB] }) =>\n          `Field should contain either \"${charA}\" or \"${charB}\", but not both`\n      ),\n    },\n  }\n);\n```\n\nResult: \n\n## `not`\n\nThe `not` operator passes when the provided rule fails and fails when the rule passes. It can be combined with other rules.\n\n```ts\nimport { useRegle } from '@regle/core';\nimport { not, required, sameAs, withMessage } from '@regle/rules';\nimport { ref } from 'vue';\n\nconst form = ref({ oldPassword: '', newPassword: '' });\nconst { r$ } = useRegle(form, {\n  oldPassword: {\n    required,\n  },\n  newPassword: {\n    notEqual: withMessage(\n      not(sameAs(() => form.value.oldPassword)),\n      'Your confirm new password must not be the same as your old password'\n    ),\n  },\n});\n```\n\nResult: \n\n## `applyIf`\n\nThe `applyIf` operator is similar to `requiredIf`, but it can be used with any rule. It simplifies conditional rule declarations.\n\n```ts\nimport { minLength, applyIf } from '@regle/rules';\n\nconst condition = ref(false);\n\nconst { r$ } = useRegle({name: ''}, {\n  name: {\n    minLength: applyIf(condition, minLength(6))\n  },\n});\n```\n\n## `assignIf`\n\nThe `assignIf` is a shorthand for conditional destructuring assignment.\nIt allows to apply multiple rules to a field conditionally.\n\n```ts\nimport { required, email, minLength, assignIf } from '@regle/rules';\n\nconst condition = ref(false);\n\nconst { r$ } = useRegle(ref({ name: '', email: '' }), {\n  name: assignIf(condition, { required, minLength: minLength(4) }),\n  email: { email },\n});\n```\n\n## `pipe`\n\nThe `pipe` operator chains multiple rules together sequentially. Each rule only runs if all previous rules have passed. This is useful when you want to validate in a specific order and avoid running expensive validations (like async checks) until simpler ones pass.\n\n```ts\nimport { useRegle } from '@regle/core';\nimport { pipe, required, minLength, email } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { email: '' },\n  {\n    email: pipe(required, minLength(5), email),\n  }\n);\n// minLength only runs if required passes\n// email only runs if both required and minLength pass\n```\n\nResult: \n\n:::tip When to use `pipe` vs `and`\n- Use **`and`** when all rules should run simultaneously and you want all errors at once\n- Use **`pipe`** when rules should run sequentially and later rules depend on earlier ones passing (e.g., don't check email format until the field has enough characters)\n:::\n\nThe `pipe` operator also works with async rules. Subsequent rules will wait for async validators to complete before running:\n\n```ts\nimport { pipe, required, withAsync } from '@regle/rules';\n\nconst checkEmailAvailable = withAsync(async (value) => {\n  const response = await fetch(`/api/check-email?email=${value}`);\n  return response.ok;\n});\n\nconst { r$ } = useRegle(\n  { email: '' },\n  {\n    email: pipe(required, email, checkEmailAvailable),\n  }\n);\n// checkEmailAvailable only runs after required and email pass\n```\n\n### Debouncing async validators\n\nWhen using `pipe` with async validators, you can configure a debounce delay to prevent too many API calls while the user is typing. Use the array syntax with an options object as the second argument:\n\n```ts\nimport { pipe, required, email, withAsync } from '@regle/rules';\n\nconst checkEmailAvailable = withAsync(async (value) => {\n  const response = await fetch(`/api/check-email?email=${value}`);\n  return response.ok;\n});\n\nconst { r$ } = useRegle(\n  { email: '' },\n  {\n    email: pipe(\n      [required, email, checkEmailAvailable],\n      { debounce: 300 } // Wait 300ms after last input before running async validators\n    ),\n  }\n);\n```\n\nThe debounce option only affects async validators in the pipe. Synchronous validators (`required`, `email` in the example above) run immediately, while the async validator (`checkEmailAvailable`) will be debounced.\n\n:::info Default debounce\nWhen using `pipe` with async validators, the default debounce delay is **200ms**. You can override this by passing a custom `debounce` value in the options.\n:::"
 		},
 		{
 			"id": "core-concepts-rules-rules-properties",
@@ -307,7 +314,7 @@ var docs_data_default = {
 			"title": "Type safe output",
 			"category": "typescript",
 			"path": "typescript/type-safe-output.md",
-			"content": "# Type safe output\n\nWhat would be the benefit of building a validation library without a type safe output?\n\nInspired by the `Zod` parse output type, `Regle` will also infer your validator types to know which properties are _**guaranteed**_ to be defined.\n\n## `$validate`  \n\nUsing `r$.$validate` will asynchronously run and wait for all your validators to finish, and will return an object containing the status of your form.\n\n```ts\nconst { valid, data, errors, issues } = await r$.$validate();\n```\n\nIf your *_result_* is `true`, the **data** will be type safe.\n\nIt will check if the `required` rule is present, but it will not work with `requiredIf` or `requiredUnless`, because we can't know the condition at build time.\n\n```ts twoslash\nimport { useRegle } from '@regle/core';\nimport { ref, type Ref, computed } from 'vue';\nimport { required } from '@regle/rules';\n// ---cut---\ntype Form = {\n  firstName?: string;\n  lastName?: string;\n}\n\nconst form = ref<Form>({ firstName: '', lastName: '' })\n\nconst { r$ } = useRegle(form, {\n  lastName: { required },\n});\n\nasync function submit() {\n  const { valid, data, errors, issues } = await r$.$validate();\n\n  if (valid) {\n    console.log(data);\n    \n  }\n}\n```\n\n<br/>\n\n### `InferSafeOutput`\n\nYou can also statically infer the safe output from any `r$` instance.\n\n```ts twoslash\nimport { ref, type Ref, computed } from 'vue';\nimport { required } from '@regle/rules';\n// ---cut---\nimport { useRegle, InferSafeOutput } from '@regle/core';\ntype Form = {\n  firstName?: string;\n  lastName?: string;\n}\n\nconst form: Ref<Form> = ref({ firstName: '', lastName: '' })\n\nconst { r$ } = useRegle(form, {\n  lastName: { required },\n});\n\ntype FormRequest = InferSafeOutput<typeof r$>;\n\n```"
+			"content": "# Type safe output\n\nWhat would be the benefit of building a validation library without a type safe output?\n\nInspired by the `Zod` parse output type, `Regle` will also infer your validator types to know which properties are _**guaranteed**_ to be defined.\n\n## `$validate`  \n\nUsing `r$.$validate` will asynchronously run and wait for all your validators to finish, and will return an object containing the status of your form.\n\n```ts\nconst { valid, data, errors, issues } = await r$.$validate();\n```\n\nIf your *_result_* is `true`, the **data** will be type safe.\n\nIt will check the rules to get the ones that ensure the value is set (`required`, `literal`, `checked`)\n\nTt will not work with `requiredIf` or `requiredUnless`, because we can't know the condition at build time.\n\n```ts twoslash\nimport { useRegle } from '@regle/core';\nimport { ref, type Ref, computed } from 'vue';\nimport { required } from '@regle/rules';\n// ---cut---\ntype Form = {\n  firstName?: string;\n  lastName?: string;\n}\n\nconst form = ref<Form>({ firstName: '', lastName: '' })\n\nconst { r$ } = useRegle(form, {\n  lastName: { required },\n});\n\nasync function submit() {\n  const { valid, data, errors, issues } = await r$.$validate();\n\n  if (valid) {\n    console.log(data);\n    \n  }\n}\n```\n\n<br/>\n\n### `InferSafeOutput`\n\nYou can also statically infer the safe output from any `r$` instance.\n\n```ts twoslash\nimport { ref, type Ref, computed } from 'vue';\nimport { required } from '@regle/rules';\n// ---cut---\nimport { useRegle, InferSafeOutput } from '@regle/core';\ntype Form = {\n  firstName?: string;\n  lastName?: string;\n}\n\nconst form: Ref<Form> = ref({ firstName: '', lastName: '' })\n\nconst { r$ } = useRegle(form, {\n  lastName: { required },\n});\n\ntype FormRequest = InferSafeOutput<typeof r$>;\n\n```"
 		},
 		{
 			"id": "typescript-typing-props",
@@ -332,11 +339,11 @@ var docs_data_default = {
 				"description": "Create a typed custom rule that can be used like built-in rules.\nThe created rule can be declared in global options or used directly.\n\nFeatures:\n- Automatically detects if the rule is async\n- Supports parameters for configurable rules\n- Full TypeScript type inference\n- Custom metadata support",
 				"parameters": [{
 					"name": "definition",
-					"type": "RegleRuleInit<TValue, TParams, TReturn, TMetadata, TAsync>",
+					"type": "RegleRuleInit<TType, TValue, TParams, TReturn, TMetadata, TAsync, TNonEmpty>",
 					"description": "- The rule definition object containing:\n- `validator`: The validation function\n- `message`: Error message (string or function)\n- `type`: Optional rule type identifier\n- `active`: Optional function to conditionally activate the rule\n- `tooltip`: Optional tooltip message",
 					"optional": false
 				}],
-				"returnType": "InferRegleRule<TValue, TParams, TAsync, TMetadata>",
+				"returnType": "InferRegleRule<TType, TValue, TParams, TAsync, TMetadata, TNonEmpty>",
 				"example": "import { createRule } from '@regle/core';\nimport { isFilled } from '@regle/rules';\n\n// Simple rule without params\nexport const isFoo = createRule({\n  validator(value: Maybe<string>) {\n    if (isFilled(value)) {\n      return value === 'foo';\n    }\n    return true;\n  },\n  message: \"The value should be 'foo'\"\n});\n\n// Rule with parameters\nexport const minCustom = createRule({\n  validator(value: Maybe<number>, min: number) {\n    if (isFilled(value)) {\n      return value >= min;\n    }\n    return true;\n  },\n  message: ({ $params: [min] }) => `Value must be at least ${min}`\n});\n\n// Usage\nuseRegle({ name: '' }, { name: { isFoo } });\nuseRegle({ count: 0 }, { count: { minCustom: minCustom(5) } });",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/reusable-rules Documentation" }
 			},
@@ -685,7 +692,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string, [options?: CommonAlphaOptions], false, boolean, string, string>",
+				"returnType": "RegleRuleDefinition<\"alpha\", string, [options?: CommonAlphaOptions], false, boolean, string, string, boolean>",
 				"example": "import { alpha } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    alpha,\n    // or with symbols allowed\n    alpha: alpha({ allowSymbols: true }),\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#alpha Documentation" }
 			},
@@ -699,7 +706,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | number, [options?: CommonAlphaOptions], false, boolean, string, string | number>",
+				"returnType": "RegleRuleDefinition<\"alphaNum\", string | number, [options?: CommonAlphaOptions], false, boolean, string, string | number, boolean>",
 				"example": "import { alphaNum } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    alphaNum,\n    // or with symbols allowed\n    alphaNum: alphaNum({ allowSymbols: true }),\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#alphanum Documentation" }
 			},
@@ -713,7 +720,7 @@ var docs_data_default = {
 					"description": "- Two or more rules to combine",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<\n  ExtractValueFromRules<TRules>[number],\n  UnwrapTuples<ExtractParamsFromRules<TRules>>,\n  GuessAsyncFromRules<TRules>,\n  GuessMetadataFromRules<TRules>\n>",
+				"returnType": "RegleRuleDefinition<\n  'and',\n  ExtractValueFromRules<TRules>[number],\n  UnwrapTuples<ExtractParamsFromRules<TRules>>,\n  GuessAsyncFromRules<TRules>,\n  GuessMetadataFromRules<TRules>,\n  ExtractValueFr...",
 				"example": "import { useRegle } from '@regle/core';\nimport { and, startsWith, endsWith, withMessage } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { regex: '' },\n  {\n    regex: {\n      myError: withMessage(\n        and(startsWith('^'), endsWith('$')),\n        ({ $params: [start, end] }) =>\n          `Regex should start with \"${start}\" and end with \"${end}\"`\n      ),\n    },\n  }\n);",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/rules-operators#and Documentation" }
 			},
@@ -721,18 +728,27 @@ var docs_data_default = {
 				"name": "applyIf",
 				"kind": "function",
 				"description": "The `applyIf` operator is similar to `requiredIf`, but it can be used with **any rule**.\nIt simplifies conditional rule declarations.",
-				"parameters": [{
-					"name": "_condition",
-					"type": "MaybeRefOrGetter<boolean>",
-					"description": "- The condition to check (ref, getter, or value)",
-					"optional": false
-				}, {
-					"name": "rule",
-					"type": "TRule",
-					"description": "- The rule to apply conditionally",
-					"optional": false
-				}],
-				"returnType": "TRule extends InlineRuleDeclaration<infer TValue, infer TParams, infer TReturn>\n  ? RegleRuleDefinition<\n      TValue,\n      [...TParams, condition: boolean],\n      TReturn extends Promise<any> ? true...",
+				"parameters": [
+					{
+						"name": "_condition",
+						"type": "MaybeRefOrGetter<boolean>",
+						"description": "- The condition to check (ref, getter, or value)",
+						"optional": false
+					},
+					{
+						"name": "rule",
+						"type": "TRule",
+						"description": "- The rule to apply conditionally",
+						"optional": false
+					},
+					{
+						"name": "options",
+						"type": "ApplyIfOptions",
+						"description": "",
+						"optional": true
+					}
+				],
+				"returnType": "TRule extends InlineRuleDeclaration<infer TValue, infer TParams, infer TReturn>\n  ? RegleRuleDefinition<\n      'applyIf',\n      TValue,\n      [...TParams, condition: boolean],\n      TReturn extends Pr...",
 				"example": "import { minLength, applyIf } from '@regle/rules';\n\nconst condition = ref(false);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    minLength: applyIf(condition, minLength(6))\n  },\n});",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/rules-operators#applyif Documentation" }
 			},
@@ -764,6 +780,20 @@ var docs_data_default = {
 				"example": "import { required, email, minLength, assignIf } from '@regle/rules';\n\nconst condition = ref(false);\n\nconst { r$ } = useRegle(ref({ name: '', email: '' }), {\n  name: assignIf(condition, { required, minLength: minLength(4) }),\n  email: { email },\n});",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/rules-operators#assignif Documentation" }
 			},
+			{
+				"name": "atLeastOne",
+				"kind": "const",
+				"description": "Checks if at least one key is filled in the object.",
+				"parameters": [{
+					"name": "keys",
+					"type": "MaybeRefOrGetter<(NoInfer<keyof T> & string)[]>",
+					"description": "",
+					"optional": true
+				}],
+				"returnType": "RegleRuleDefinition<\"atLeastOne\", T, [keys?: (NoInfer<keyof T> & string)[]], false, boolean, false, T, boolean>",
+				"example": "import { atLeastOne } from '@regle/rules';\n\nconst { r$ } = useRegle({ user: { firstName: '', lastName: '' } }, {\n  user: {\n   atLeastOne,\n   // or\n   atLeastOne: atLeastOne(['firstName', 'lastName'])\n   // or\n   atLeastOne: atLeastOne<{ firstName: string; lastName: string }>(['firstName', 'lastName'])\n  },\n});",
+				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#atleastone Documentation" }
+			},
 			{
 				"name": "between",
 				"kind": "const",
@@ -774,7 +804,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<number, [min: number, max: number, options?: CommonComparisonOptions], false, boolean, number, number>",
+				"returnType": "RegleRuleDefinition<\"between\", number, [min: number, max: number, options?: CommonComparisonOptions], false, boolean, number, number, boolean>",
 				"example": "import { between } from '@regle/rules';\n\nconst maxCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    between: between(1, 6),\n    // or with reactive max\n    between: between(1, maxCount, { allowEqual: false }),\n    // or with getter\n    between: between(() => maxCount.value, 10)\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#between Documentation" }
 			},
@@ -806,7 +836,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string, [part: string], false, boolean, string, string>",
+				"returnType": "RegleRuleDefinition<\"contains\", string, [part: string], false, boolean, string, string, boolean>",
 				"example": "import { contains } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestLib: '' }, {\n  bestLib: {\n    contains: contains('regle')\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#contains Documentation" }
 			},
@@ -829,7 +859,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | Date, [after: string | Date, options?: CommonComparisonOptions], false, true | { $valid: false; error: \"date-not-after\"; } | { $valid: false; error: \"value-or-parameter-no...",
+				"returnType": "RegleRuleDefinition<\"dateAfter\", string | Date, [after: string | Date, options?: CommonComparisonOptions], false, true | { $valid: false; error: \"date-not-after\"; } | { ...; }, string | Date, string |...",
 				"example": "import { dateAfter } from '@regle/rules';\n\nconst { r$ } = useRegle({ birthday: null as Date | null }, {\n  birthday: {\n    dateAfter: dateAfter(new Date()),\n    // or with options\n    dateAfter: dateAfter(new Date(), { allowEqual: false }),\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#dateafter Documentation" }
 			},
@@ -843,7 +873,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | Date, [before: string | Date, options?: CommonComparisonOptions], false, true | { $valid: false; error: \"date-not-before\"; } | { $valid: false; error: \"value-or-parameter-...",
+				"returnType": "RegleRuleDefinition<\"dateBefore\", string | Date, [before: string | Date, options?: CommonComparisonOptions], false, true | { $valid: false; error: \"date-not-before\"; } | { ...; }, string | Date, strin...",
 				"example": "import { dateBefore } from '@regle/rules';\n\nconst { r$ } = useRegle({ birthday: null as Date | null }, {\n  birthday: {\n    dateBefore: dateBefore(new Date()),\n    // or with options\n    dateBefore: dateBefore(new Date(), { allowEqual: false }),\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#datebefore Documentation" }
 			},
@@ -857,7 +887,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | Date, [before: string | Date, after: string | Date, options?: CommonComparisonOptions], false, boolean, string | Date, string | Date>",
+				"returnType": "RegleRuleDefinition<\"dateBetween\", string | Date, [before: string | Date, after: string | Date, options?: CommonComparisonOptions], false, boolean, string | Date, string | Date, boolean>",
 				"example": "import { dateBetween } from '@regle/rules';\n\nconst { r$ } = useRegle({ birthday: null as Date | null }, {\n  birthday: {\n    dateBetween: dateBetween(new Date(), new Date(2030, 3, 1)),\n    // or with options\n    dateBetween: dateBetween(new Date(), new Date(2030, 3, 1), { allowEqual: false }),\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#datebetween Documentation" }
 			},
@@ -898,7 +928,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string, [part: string], false, boolean, string, string>",
+				"returnType": "RegleRuleDefinition<\"endsWith\", string, [part: string], false, boolean, string, string, boolean>",
 				"example": "import { endsWith } from '@regle/rules';\n\nconst { r$ } = useRegle({ firstName: '' }, {\n  firstName: { endsWith: endsWith('foo') },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#endswith Documentation" }
 			},
@@ -912,7 +942,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | number, [count: number], false, boolean, unknown, string | number>",
+				"returnType": "RegleRuleDefinition<\"exactDigits\", string | number, [count: number], false, boolean, unknown, string | number, boolean>",
 				"example": "import { exactDigits } from '@regle/rules';\n\nconst exactValue = ref(6);\n\nconst { r$ } = useRegle({ digits: '' }, {\n  digits: {\n    exactDigits: exactDigits(6),\n    // or with reactive value\n    exactDigits: exactDigits(exactValue),\n    // or with getter\n    exactDigits: exactDigits(() => exactValue.value)\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#exactdigits Documentation" }
 			},
@@ -926,7 +956,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | any[] | Record<PropertyKey, any>, [count: number], false, boolean, unknown, string | any[] | Record<PropertyKey, any>>",
+				"returnType": "RegleRuleDefinition<\"exactLength\", string | any[] | Record<PropertyKey, any>, [count: number], false, boolean, unknown, string | any[] | Record<PropertyKey, any>, boolean>",
 				"example": "import { exactLength } from '@regle/rules';\n\nconst exactValue = ref(6);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    exactLength: exactLength(6),\n    // or with reactive value\n    exactLength: exactLength(exactValue),\n    // or with getter\n    exactLength: exactLength(() => exactValue.value)\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#exactlength Documentation" }
 			},
@@ -940,7 +970,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<number, [count: number], false, boolean, number, number>",
+				"returnType": "RegleRuleDefinition<\"exactValue\", number, [count: number], false, boolean, number, number, boolean>",
 				"example": "import { exactValue } from '@regle/rules';\n\nconst exactCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    exactValue: exactValue(6),\n    // or with reactive value\n    exactValue: exactValue(exactCount),\n    // or with getter\n    exactValue: exactValue(() => exactCount.value)\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#exactvalue Documentation" }
 			},
@@ -963,7 +993,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<File, [accept: readonly string[]], false, boolean, unknown, File>",
+				"returnType": "RegleRuleDefinition<\"fileType\", File, [accept: readonly string[]], false, boolean, unknown, File, boolean>",
 				"example": "import { type InferInput } from '@regle/core';\nimport { fileType } from '@regle/rules';\n\nconst {r$} = useRegle({ file: null as File | null }, {\n  file: { fileType: fileType(['image/png', 'image/jpeg']) },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#filetype Documentation" }
 			},
@@ -1009,7 +1039,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string, [options?: UrlOptions], false, boolean, unknown, string>",
+				"returnType": "RegleRuleDefinition<\"httpUrl\", string, [options?: UrlOptions], false, boolean, unknown, string, boolean>",
 				"example": "import { httpUrl } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestUrl: '' }, {\n  bestUrl: { httpUrl },\n  // or to force https protocol\n  bestUrl: { httpUrl: httpUrl({ protocol: /^https$/ }) },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#httpurl Documentation" }
 			},
@@ -1049,17 +1079,26 @@ var docs_data_default = {
 				"name": "isEmpty",
 				"kind": "function",
 				"description": "Checks if a value is empty in any way (including arrays and objects).\nThis is the inverse of `isFilled`.\n\n`isEmpty` also acts as a type guard.\n\nBy default, it considers an empty array as `true`. You can override this behavior with `considerEmptyArrayInvalid`.",
-				"parameters": [{
-					"name": "value",
-					"type": "unknown",
-					"description": "- The target value to check",
-					"optional": false
-				}, {
-					"name": "considerEmptyArrayInvalid",
-					"type": "boolean",
-					"description": "- When `false`, empty arrays are not considered empty (default: `true`)",
-					"optional": false
-				}],
+				"parameters": [
+					{
+						"name": "value",
+						"type": "unknown",
+						"description": "- The target value to check",
+						"optional": false
+					},
+					{
+						"name": "considerEmptyArrayInvalid",
+						"type": "boolean",
+						"description": "- When `false`, empty arrays are not considered empty (default: `true`)",
+						"optional": false
+					},
+					{
+						"name": "considerEmptyObjectInvalid",
+						"type": "boolean",
+						"description": "",
+						"optional": false
+					}
+				],
 				"returnType": "value is null | undefined | [] | EmptyObject",
 				"example": "import { createRule, type Maybe } from '@regle/core';\nimport { isEmpty } from '@regle/rules';\n\nconst rule = createRule({\n  validator(value: Maybe<string>) {\n    if (isEmpty(value)) {\n      return true;\n    }\n    return check(value);\n  },\n  message: 'Error'\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/validations-helpers#isempty Documentation" }
@@ -1068,17 +1107,26 @@ var docs_data_default = {
 				"name": "isFilled",
 				"kind": "function",
 				"description": "Checks if any value you provide is defined (including arrays and objects).\nThis is almost a must-have for optional fields when writing custom rules.\n\n`isFilled` also acts as a type guard.\n\nBy default, it considers an empty array as `false`. You can override this behavior with `considerEmptyArrayInvalid`.",
-				"parameters": [{
-					"name": "value",
-					"type": "T",
-					"description": "- The target value to check",
-					"optional": false
-				}, {
-					"name": "considerEmptyArrayInvalid",
-					"type": "boolean",
-					"description": "- When `false`, empty arrays are considered filled (default: `true`)",
-					"optional": false
-				}],
+				"parameters": [
+					{
+						"name": "value",
+						"type": "T",
+						"description": "- The target value to check",
+						"optional": false
+					},
+					{
+						"name": "considerEmptyArrayInvalid",
+						"type": "boolean",
+						"description": "- When `false`, empty arrays are considered filled (default: `true`)",
+						"optional": false
+					},
+					{
+						"name": "considerEmptyObjectInvalid",
+						"type": "boolean",
+						"description": "",
+						"optional": false
+					}
+				],
 				"returnType": "value is NonNullable<T>",
 				"example": "import { createRule } from '@regle/core';\nimport { isFilled } from '@regle/rules';\n\nconst rule = createRule({\n  validator(value: unknown) {\n    if (isFilled(value)) {\n      return check(value);\n    }\n    return true;\n  },\n  message: 'Error'\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/validations-helpers#isfilled Documentation" }
@@ -1107,7 +1155,7 @@ var docs_data_default = {
 					"description": "- The literal value to match",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<TValue, [literal: TValue], false, boolean, MaybeInput<TValue>, string | number>",
+				"returnType": "RegleRuleDefinition<\n  'literal',\n  TValue,\n  [literal: TValue],\n  false,\n  boolean,\n  MaybeInput<TValue>,\n  string | number,\n  true\n>",
 				"example": "import { literal } from '@regle/rules';\n\nconst { r$ } = useRegle({ status: '' }, {\n  status: { literal: literal('active') },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#literal Documentation" }
 			},
@@ -1130,7 +1178,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string, [separator?: string], false, boolean, string, string>",
+				"returnType": "RegleRuleDefinition<\"macAddress\", string, [separator?: string], false, boolean, string, string, boolean>",
 				"example": "import { macAddress } from '@regle/rules';\n\nconst { r$ } = useRegle({ address: '' }, {\n  address: {\n    macAddress,\n    // or with custom separator\n    macAddress: macAddress('-')\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#macaddress Documentation" }
 			},
@@ -1163,7 +1211,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<File, [maxSize: number], false, true | { $valid: boolean; fileSize: number; }, unknown, File>",
+				"returnType": "RegleRuleDefinition<\"maxFileSize\", File, [maxSize: number], false, true | { $valid: boolean; fileSize: number; }, unknown, File, boolean>",
 				"example": "import { type InferInput } from '@regle/core';\nimport { maxFileSize } from '@regle/rules';\n\nconst {r$} = useRegle({ file: null as File | null }, {\n  file: { maxFileSize: maxFileSize(10_000_000) }, // 10 MB\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#maxfilesize Documentation" }
 			},
@@ -1177,7 +1225,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | any[] | Record<PropertyKey, any>, [max: number, options?: CommonComparisonOptions], false, boolean, unknown, string | any[] | Record<PropertyKey, any>>",
+				"returnType": "RegleRuleDefinition<\"maxLength\", string | any[] | Record<PropertyKey, any>, [max: number, options?: CommonComparisonOptions], false, boolean, unknown, string | any[] | Record<...>, boolean>",
 				"example": "import { maxLength } from '@regle/rules';\n\nconst maxValue = ref(6);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    maxLength: maxLength(6),\n    // or with reactive value\n    maxLength: maxLength(maxValue),\n    // or with getter\n    maxLength: maxLength(() => maxValue.value)\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#maxlength Documentation" }
 			},
@@ -1191,7 +1239,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | number, [max: string | number, options?: CommonComparisonOptions], false, boolean, string | number, string | number>",
+				"returnType": "RegleRuleDefinition<\"maxValue\", string | number, [max: string | number, options?: CommonComparisonOptions], false, boolean, string | number, string | number, boolean>",
 				"example": "import { maxValue } from '@regle/rules';\n\nconst maxCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    maxValue: maxValue(6),\n    // or with options\n    maxValue: maxValue(maxCount, { allowEqual: false }),\n    // or with getter\n    maxValue: maxValue(() => maxCount.value)\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#maxvalue Documentation" }
 			},
@@ -1205,7 +1253,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<File, [minSize: number], false, true | { $valid: boolean; fileSize: number; }, unknown, File>",
+				"returnType": "RegleRuleDefinition<\"minFileSize\", File, [minSize: number], false, true | { $valid: boolean; fileSize: number; }, unknown, File, boolean>",
 				"example": "import { type InferInput } from '@regle/core';\nimport { minFileSize } from '@regle/rules';\n\nconst {r$} = useRegle({ file: null as File | null }, {\n  file: { minFileSize: minFileSize(1_000_000) }, // 1 MB\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#minfilesize Documentation" }
 			},
@@ -1219,7 +1267,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | any[] | Record<PropertyKey, any>, [min: number, options?: CommonComparisonOptions], false, boolean, unknown, string | any[] | Record<PropertyKey, any>>",
+				"returnType": "RegleRuleDefinition<\"minLength\", string | any[] | Record<PropertyKey, any>, [min: number, options?: CommonComparisonOptions], false, boolean, unknown, string | any[] | Record<...>, boolean>",
 				"example": "import { minLength } from '@regle/rules';\n\nconst minValue = ref(6);\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    minLength: minLength(6),\n    // or with reactive value\n    minLength: minLength(minValue),\n    // or with getter\n    minLength: minLength(() => minValue.value)\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#minlength Documentation" }
 			},
@@ -1233,7 +1281,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | number, [min: string | number, options?: CommonComparisonOptions], false, boolean, string | number, string | number>",
+				"returnType": "RegleRuleDefinition<\"minValue\", string | number, [min: string | number, options?: CommonComparisonOptions], false, boolean, string | number, string | number, boolean>",
 				"example": "import { minValue } from '@regle/rules';\n\nconst minCount = ref(6);\n\nconst { r$ } = useRegle({ count: 0 }, {\n  count: {\n    minValue: minValue(6),\n    // or with options\n    minValue: minValue(minCount, { allowEqual: false }),\n    // or with getter\n    minValue: minValue(() => minCount.value)\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#minvalue Documentation" }
 			},
@@ -1247,7 +1295,7 @@ var docs_data_default = {
 					"description": "- The TypeScript enum to validate against",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<MaybeInput<T[keyof T]>, [enumLike: T], false, boolean, MaybeInput<T[keyof T]>, string | number>",
+				"returnType": "RegleRuleDefinition<\n  'nativeEnum',\n  MaybeInput<T[keyof T]>,\n  [enumLike: T],\n  false,\n  boolean,\n  MaybeInput<T[keyof T]>,\n  string | number\n>",
 				"example": "import { nativeEnum } from '@regle/rules';\n\nenum Foo {\n  Bar, Baz\n}\n\nconst { r$ } = useRegle({ type: '' }, {\n  type: { nativeEnum: nativeEnum(Foo) },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#nativeenum Documentation" }
 			},
@@ -1257,7 +1305,7 @@ var docs_data_default = {
 				"description": "The `not` operator passes when the provided rule **fails** and fails when the rule **passes**.\nIt can be combined with other rules.",
 				"parameters": [{
 					"name": "rule",
-					"type": "RegleRuleDefinition<TValue, TParams, TAsync, TMetadata, unknown, TValue extends Date & File & infer M ? M : TValue> | InlineRuleDeclaration<...>",
+					"type": "RegleRuleDefinition<TType, TValue, TParams, TAsync, TMetadata, unknown, TValue extends Date & File & infer M ? M : TValue, boolean> | InlineRuleDeclaration<...>",
 					"description": "- The rule to negate",
 					"optional": false
 				}, {
@@ -1266,7 +1314,7 @@ var docs_data_default = {
 					"description": "- Optional custom error message",
 					"optional": true
 				}],
-				"returnType": "RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>",
+				"returnType": "RegleRuleDefinition<\n  IsUnknown<TType> extends true ? 'not' : `not:${TType & string}`,\n  TValue,\n  TParams,\n  TAsync,\n  TMetadata\n>",
 				"example": "import { useRegle } from '@regle/core';\nimport { not, required, sameAs, withMessage } from '@regle/rules';\nimport { ref } from 'vue';\n\nconst form = ref({ oldPassword: '', newPassword: '' });\n\nconst { r$ } = useRegle(form, {\n  oldPassword: { required },\n  newPassword: {\n    notEqual: withMessage(\n      not(sameAs(() => form.value.oldPassword)),\n      'Your new password must not be the same as your old password'\n    ),\n  },\n});",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/rules-operators#not Documentation" }
 			},
@@ -1298,7 +1346,7 @@ var docs_data_default = {
 					"description": "- Array of allowed values",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<TValues[number], [options: TValues], false, boolean, TValues[number], string | number>",
+				"returnType": "RegleRuleDefinition<\"oneOf\", TValues[number], [options: TValues], false, boolean, TValues[number], string | number, boolean>",
 				"example": "import { oneOf } from '@regle/rules';\n\nconst { r$ } = useRegle({ aliment: 'Fish' }, {\n  aliment: {\n    oneOf: oneOf(['Fish', 'Meat', 'Bone'])\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#oneof Documentation" }
 			},
@@ -1312,10 +1360,24 @@ var docs_data_default = {
 					"description": "- Two or more rules to combine",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<\n  ExtractValueFromRules<TRules>[number],\n  UnwrapTuples<ExtractParamsFromRules<TRules>>,\n  GuessAsyncFromRules<TRules>,\n  GuessMetadataFromRules<TRules>\n>",
+				"returnType": "RegleRuleDefinition<\n  'or',\n  ExtractValueFromRules<TRules>[number],\n  UnwrapTuples<ExtractParamsFromRules<TRules>>,\n  GuessAsyncFromRules<TRules>,\n  GuessMetadataFromRules<TRules>\n>",
 				"example": "import { useRegle } from '@regle/core';\nimport { or, startsWith, endsWith, withMessage } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { regex: '' },\n  {\n    regex: {\n      myError: withMessage(\n        or(startsWith('^'), endsWith('$')),\n        ({ $params: [start, end] }) =>\n          `Field should start with \"${start}\" or end with \"${end}\"`\n      ),\n    },\n  }\n);",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/rules-operators#or Documentation" }
 			},
+			{
+				"name": "pipe",
+				"kind": "function",
+				"description": "The `pipe` operator chains multiple rules together, where each rule only runs\nif all previous rules have passed. This is useful for sequential validation\nwhere later rules depend on earlier ones passing.",
+				"parameters": [{
+					"name": "rules",
+					"type": "TRulesDelc",
+					"description": "- Two or more rules to chain together",
+					"optional": false
+				}],
+				"returnType": "Prettify<PipeTupleToObject<TRulesDelc>>",
+				"example": "import { useRegle } from '@regle/core';\nimport { pipe, required, minLength, email } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { email: '' },\n  {\n    email: pipe(required, minLength(5), email),\n  }\n);\n// minLength only runs if required passes\n// email only runs if both required and minLength pass",
+				"tags": { "see": "://reglejs.dev/core-concepts/rules/rules-operators#pipe Documentation" }
+			},
 			{
 				"name": "regex",
 				"kind": "const",
@@ -1326,7 +1388,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string | number, [regexp: RegExp | RegExp[]], false, boolean, string | number, string | number>",
+				"returnType": "RegleRuleDefinition<\"regex\", string | number, [regexp: RegExp | RegExp[]], false, boolean, string | number, string | number, boolean>",
 				"example": "import { regex } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    regex: regex(/^foo/),\n    // or with multiple patterns\n    regex: regex([/^bar/, /baz$/]),\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#regex Documentation" }
 			},
@@ -1349,7 +1411,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<unknown, [condition: boolean], false, boolean, unknown, unknown>",
+				"returnType": "RegleRuleDefinition<\"required\", unknown, [condition: boolean], false, boolean, unknown, unknown, boolean>",
 				"example": "import { requiredIf } from '@regle/rules';\n\nconst form = ref({ name: '', condition: false });\nconst conditionRef = ref(false);\n\nconst { r$ } = useRegle(form, {\n  name: {\n    required: requiredIf(() => form.value.condition),\n    // or with a ref\n    required: requiredIf(conditionRef),\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#requiredif Documentation" }
 			},
@@ -1363,7 +1425,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<unknown, [condition: boolean], false, boolean, unknown, unknown>",
+				"returnType": "RegleRuleDefinition<\"required\", unknown, [condition: boolean], false, boolean, unknown, unknown, boolean>",
 				"example": "import { requiredUnless } from '@regle/rules';\n\nconst form = ref({ name: '', condition: false });\nconst conditionRef = ref(false);\n\nconst { r$ } = useRegle(form, {\n  name: {\n    required: requiredUnless(() => form.value.condition),\n    // or with a ref\n    required: requiredUnless(conditionRef)\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#requiredunless Documentation" }
 			},
@@ -1382,7 +1444,7 @@ var docs_data_default = {
 					"description": "- Optional name for the other field (used in error message)",
 					"optional": true
 				}],
-				"returnType": "RegleRuleDefinition<TTarget, [target: TTarget, otherName?: string], false, boolean, TTarget extends infer M ? M : TTarget, TTarget extends Date & File & infer M ? M : TTarget>",
+				"returnType": "RegleRuleDefinition<\"sameAs\", TTarget, [target: TTarget, otherName?: string], false, boolean, TTarget extends infer M ? M : TTarget, TTarget extends Date & ... 1 more ... & infer M ? M : TTarget, bool...",
 				"example": "import { sameAs } from '@regle/rules';\n\nconst form = ref({\n  password: '',\n  confirmPassword: '',\n});\n\nconst { r$ } = useRegle(form, {\n  confirmPassword: {\n    sameAs: sameAs(() => form.value.password),\n  }\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#sameas Documentation" }
 			},
@@ -1396,7 +1458,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string, [part: string], false, boolean, string, string>",
+				"returnType": "RegleRuleDefinition<\"startsWith\", string, [part: string], false, boolean, string, string, boolean>",
 				"example": "import { startsWith } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestLib: '' }, {\n  bestLib: {\n    startsWith: startsWith('regle')\n  },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#startswith Documentation" }
 			},
@@ -1442,7 +1504,7 @@ var docs_data_default = {
 				"kind": "function",
 				"description": "Define the input type of a rule. No runtime validation.\n\nOverride any input type set by other rules.",
 				"parameters": [],
-				"returnType": "RegleRuleDefinition<unknown, [], false, boolean, MaybeInput<T>>",
+				"returnType": "RegleRuleDefinition<'type', unknown, [], false, boolean, MaybeInput<T>>",
 				"example": "import { type InferInput } from '@regle/core';\nimport { type } from '@regle/rules';\n\nconst rules = {\n  firstName: { type: type<string>() },\n  status: { type: type<'active' | 'inactive'>() },\n}\n\nconst state = ref<InferInput<typeof rules>>({});",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#type Documentation" }
 			},
@@ -1465,7 +1527,7 @@ var docs_data_default = {
 					"description": "",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<string, [options?: UrlOptions], false, boolean, unknown, string>",
+				"returnType": "RegleRuleDefinition<\"url\", string, [options?: UrlOptions], false, boolean, unknown, string, boolean>",
 				"example": "import { url } from '@regle/rules';\n\nconst { r$ } = useRegle({ bestUrl: '' }, {\n  bestUrl: { url },\n  // or with custom protocol validation\n  bestUrl: { url: url({ protocol: /^https?$/ }) },\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/built-in-rules#url Documentation" }
 			},
@@ -1484,7 +1546,7 @@ var docs_data_default = {
 					"description": "- Array of reactive dependencies (refs or getters)",
 					"optional": true
 				}],
-				"returnType": "RegleRuleDefinition<TValue, UnwrapRegleUniversalParams<TParams>, true, TMetadata>",
+				"returnType": "RegleRuleDefinition<unknown, TValue, UnwrapRegleUniversalParams<TParams>, true, TMetadata>",
 				"example": "import { withAsync } from '@regle/rules';\n\nconst base = ref('foo');\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    customRule: withAsync(async (value, param) => {\n      await someAsyncCall(param)\n    }, [base])\n  }\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/rule-wrappers#withasync Documentation" }
 			},
@@ -1494,7 +1556,7 @@ var docs_data_default = {
 				"description": "The `withMessage` wrapper lets you associate an error message with a rule.\nPass your rule as the first argument and the error message as the second.",
 				"parameters": [{
 					"name": "rule",
-					"type": "RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>",
+					"type": "RegleRuleWithParamsDefinition<TType, TValue, TParams, TAsync, TMetadata>",
 					"description": "- The rule to wrap (can be inline function or rule definition)",
 					"optional": false
 				}, {
@@ -1503,7 +1565,7 @@ var docs_data_default = {
 					"description": "- The error message (string or function returning a string)",
 					"optional": false
 				}],
-				"returnType": "RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>",
+				"returnType": "RegleRuleWithParamsDefinition<TType, TValue, TParams, TAsync, TMetadata>",
 				"example": "import { withMessage } from '@regle/rules';\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    // With a static message\n    customRule1: withMessage((value) => !!value, \"Custom Error\"),\n    // With dynamic message using metadata\n    customRule2: withMessage(\n      customRuleInlineWithMetaData,\n      ({ $value, foo }) => `Custom Error: ${$value} ${foo}`\n    ),\n  }\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/rule-wrappers#withmessage Documentation" }
 			},
@@ -1513,7 +1575,7 @@ var docs_data_default = {
 				"description": "The `withParams` wrapper allows your rule to depend on external parameters,\nsuch as a reactive property in your component or store.\n\nBy default, `useRegle` observes changes automatically when rules are defined using getter functions or computed properties.\nHowever, sometimes dependencies cannot be tracked automatically; use `withParams` to manually define them.",
 				"parameters": [{
 					"name": "rule",
-					"type": "InlineRuleDeclaration<TValue, TParams, TReturn> | RegleRuleDefinition<TValue, any[], TAsync, TMetadata, unknown, TValue extends Date & ... 1 more ... & infer M ? M : TValue>",
+					"type": "InlineRuleDeclaration<TValue, TParams, TReturn> | RegleRuleDefinition<TType, TValue, any[], TAsync, TMetadata, unknown, TValue extends Date & ... 1 more ... & infer M ? M : TValue, boolean>",
 					"description": "- The rule function or definition",
 					"optional": false
 				}, {
@@ -1522,7 +1584,7 @@ var docs_data_default = {
 					"description": "- Array of reactive dependencies (refs or getters)",
 					"optional": false
 				}],
-				"returnType": "RegleRuleDefinition<TValue, UnwrapRegleUniversalParams<TParams>, TAsync, TMetadata>",
+				"returnType": "RegleRuleDefinition<TType, TValue, UnwrapRegleUniversalParams<TParams>, TAsync, TMetadata>",
 				"example": "import { withParams } from '@regle/rules';\n\nconst base = ref('foo');\n\nconst { r$ } = useRegle({ name: '' }, {\n  name: {\n    customRule: withParams((value, param) => value === param, [base]),\n    // or with getter\n    customRule: withParams((value, param) => value === param, [() => base.value]),\n  }\n})",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/rule-wrappers#withparams Documentation" }
 			},
@@ -1532,7 +1594,7 @@ var docs_data_default = {
 				"description": "The `withTooltip` wrapper allows you to display additional messages for your field that aren't necessarily errors.\nTooltips are aggregated and accessible via `$tooltips` property.",
 				"parameters": [{
 					"name": "rule",
-					"type": "RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>",
+					"type": "RegleRuleWithParamsDefinition<TType, TValue, TParams, TAsync, TMetadata>",
 					"description": "- The rule to wrap (can be inline function or rule definition)",
 					"optional": false
 				}, {
@@ -1541,9 +1603,23 @@ var docs_data_default = {
 					"description": "- The tooltip message (string or function returning a string)",
 					"optional": false
 				}],
-				"returnType": "RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>",
+				"returnType": "RegleRuleWithParamsDefinition<TType, TValue, TParams, TAsync, TMetadata>",
 				"example": "import { withTooltip, minLength } from '@regle/rules';\n\nconst { r$ } = useRegle({ password: '' }, {\n  password: {\n    minLength: withTooltip(\n      minLength(8),\n      'Password should be at least 8 characters for better security'\n    ),\n  }\n})\n\n// Access tooltips via:\n// r$.password.$tooltips",
 				"tags": { "see": "://reglejs.dev/core-concepts/rules/rule-wrappers#withtooltip Documentation" }
+			},
+			{
+				"name": "xor",
+				"kind": "function",
+				"description": "The `xor` operator validates successfully if **exactly one** of the provided rules is valid (exclusive or).",
+				"parameters": [{
+					"name": "rules",
+					"type": "[...TRules]",
+					"description": "- Two or more rules to combine",
+					"optional": false
+				}],
+				"returnType": "RegleRuleDefinition<\n  'xor',\n  ExtractValueFromRules<TRules>[number],\n  UnwrapTuples<ExtractParamsFromRules<TRules>>,\n  GuessAsyncFromRules<TRules>,\n  GuessMetadataFromRules<TRules>\n>",
+				"example": "import { useRegle } from '@regle/core';\nimport { xor, contains, withMessage } from '@regle/rules';\n\nconst { r$ } = useRegle(\n  { code: '' },\n  {\n    code: {\n      myError: withMessage(\n        xor(contains('A'), contains('B')),\n        ({ $params: [charA, charB] }) =>\n          `Field should contain either \"${charA}\" or \"${charB}\", but not both`\n      ),\n    },\n  }\n);",
+				"tags": { "see": "://reglejs.dev/core-concepts/rules/rules-operators#xor Documentation" }
 			}
 		],
 		"@regle/schemas": [
@@ -1814,7 +1890,7 @@ function searchApi(query) {
 	return results;
 }
 
-var version = "1.18.0-beta.1";
+var version = "1.18.0-beta.2";
 
 let posthogClient = null;
 posthogClient = new PostHog("phc_kqgJoylCpKkGkkRGxb4MyN2mViehoQcUFEGwVkk4l8E", {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@regle/mcp-server",
-  "version": "1.18.0-beta.1",
+  "version": "1.18.0-beta.2",
   "description": "MCP Server for Regle",
   "keywords": [
     "ai",