diff --git a/README.md b/README.md
index 8862d9d..b525ca2 100644
--- a/README.md
+++ b/README.md
@@ -108,3 +108,4 @@ Alternatively, add `lingui` to the plugins section, and configure the rules you
 - [consistent-plural-format](docs/rules/consistent-plural-format.md)
 - [no-plural-inside-trans](docs/rules/no-plural-inside-trans.md)
 - [require-explicit-id](docs/rules/require-explicit-id.md)
+- [require-implicit-id](docs/rules/require-implicit-id.md)
diff --git a/docs/rules/require-explicit-id.md b/docs/rules/require-explicit-id.md
index b58b62b..00df2ad 100644
--- a/docs/rules/require-explicit-id.md
+++ b/docs/rules/require-explicit-id.md
@@ -1,19 +1,23 @@
 # require-explicit-id
 
-Enforce that `<Trans>` components and Lingui macro function calls (`t`, `msg`, `defineMessage`) have an explicit `id`.
+Enforce that `<Trans>`, `<Plural>`, `<SelectOrdinal>`, `<Select>` components and Lingui macro function calls (`t`, `msg`, `defineMessage`) have an explicit `id`.
 
-Providing an explicit `id` gives translators a stable, human-readable key and prevents auto-generated IDs from changing unexpectedly when the default message is updated.
+Providing an explicit `id` gives translators a stable, human-readable key and prevents auto-generated IDs from changing unexpectedly when the default message is updated. See [Benefits of Explicit IDs](https://lingui.dev/guides/explicit-vs-generated-ids#benefits-of-explicit-ids) in the Lingui docs for more details.
 
 Tagged template literals (`` t`Hello` ``) don't support `id` — use the function call form instead.
 
+> **⚠️ Conflicts:** This rule directly conflicts with [`require-implicit-id`](./require-implicit-id.md). Do **not** enable both rules at the same time — they are mutually exclusive.
+
 ```jsx
 // nope ⛔️
 <Trans>Read the docs for more info.</Trans>
+<Plural value={count} one="# book" other="# books" />
 t`Hello`
 t({ message: "Hello" })
 
 // ok ✅
 <Trans id="msg.docs">Read the docs for more info.</Trans>
+<Plural id="msg.books" value={count} one="# book" other="# books" />
 t({ id: "msg.hello", message: "Hello" })
 ```
 
diff --git a/docs/rules/require-implicit-id.md b/docs/rules/require-implicit-id.md
new file mode 100644
index 0000000..3bdc3c6
--- /dev/null
+++ b/docs/rules/require-implicit-id.md
@@ -0,0 +1,20 @@
+# require-implicit-id
+
+Enforce that `<Trans>`, `<Plural>`, `<SelectOrdinal>`, `<Select>` components and Lingui macro function calls (`t`, `msg`, `defineMessage`) do not have an explicit `id`.
+
+Relying on auto-generated IDs eliminates the need to maintain a separate mapping of IDs to messages and ensures the catalog stays in sync with the source code. See [Benefits of Generated IDs](https://lingui.dev/guides/explicit-vs-generated-ids#benefits-of-generated-ids) in the Lingui docs for more details.
+
+> **⚠️ Conflicts:** This rule directly conflicts with [`require-explicit-id`](./require-explicit-id.md). Do **not** enable both rules at the same time — they are mutually exclusive.
+
+```jsx
+// nope ⛔️
+<Trans id="msg.hello">Hello</Trans>
+<Plural id="msg.books" value={count} one="# book" other="# books" />
+t({ id: "msg.hello", message: "Hello" })
+
+// ok ✅
+<Trans>Hello</Trans>
+<Plural value={count} one="# book" other="# books" />
+t({ message: "Hello" })
+t`Hello`
+```
diff --git a/src/helpers.test.ts b/src/helpers.test.ts
index 2237258..65b4289 100644
--- a/src/helpers.test.ts
+++ b/src/helpers.test.ts
@@ -1,6 +1,90 @@
 import { parse } from '@typescript-eslint/parser'
 import { TSESTree } from '@typescript-eslint/utils'
-import { buildCalleePath } from './helpers'
+import { buildCalleePath, findJSXAttribute, findObjectProperty } from './helpers'
+
+describe('findJSXAttribute', () => {
+  function buildJSXElement(code: string) {
+    const t = parse(code, { jsx: true })
+    return (t.body[0] as TSESTree.ExpressionStatement).expression as TSESTree.JSXElement
+  }
+
+  it('should find an attribute by name', () => {
+    const node = buildJSXElement('<Trans id="msg.hello">Hello</Trans>')
+    const attr = findJSXAttribute(node, 'id')
+
+    expect(attr).toBeDefined()
+    expect(attr!.name.name).toBe('id')
+  })
+
+  it('should return undefined when attribute is missing', () => {
+    const node = buildJSXElement('<Trans>Hello</Trans>')
+    const attr = findJSXAttribute(node, 'id')
+
+    expect(attr).toBeUndefined()
+  })
+
+  it('should find the correct attribute among several', () => {
+    const node = buildJSXElement('<Trans id="msg.hello" context="greeting">Hello</Trans>')
+
+    expect(findJSXAttribute(node, 'id')).toBeDefined()
+    expect(findJSXAttribute(node, 'context')).toBeDefined()
+    expect(findJSXAttribute(node, 'missing')).toBeUndefined()
+  })
+
+  it('should ignore JSX spread attributes', () => {
+    const node = buildJSXElement('<Trans {...props}>Hello</Trans>')
+
+    expect(findJSXAttribute(node, 'id')).toBeUndefined()
+  })
+})
+
+describe('findObjectProperty', () => {
+  function buildObjectExpression(code: string) {
+    const t = parse(code)
+    return (t.body[0] as TSESTree.ExpressionStatement).expression as TSESTree.ObjectExpression
+  }
+
+  it('should find a property with an identifier key', () => {
+    const obj = buildObjectExpression('({ id: "msg.hello", message: "Hello" })')
+    const prop = findObjectProperty(obj, 'id')
+
+    expect(prop).toBeDefined()
+    expect((prop!.key as TSESTree.Identifier).name).toBe('id')
+  })
+
+  it('should find a property with a string literal key', () => {
+    const obj = buildObjectExpression("({ 'id': 'msg.hello', message: 'Hello' })")
+    const prop = findObjectProperty(obj, 'id')
+
+    expect(prop).toBeDefined()
+    expect((prop!.key as TSESTree.Literal).value).toBe('id')
+  })
+
+  it('should return undefined when property is missing', () => {
+    const obj = buildObjectExpression('({ message: "Hello" })')
+    const prop = findObjectProperty(obj, 'id')
+
+    expect(prop).toBeUndefined()
+  })
+
+  it('should find the correct property among several', () => {
+    const obj = buildObjectExpression(
+      '({ id: "msg.hello", message: "Hello", context: "greeting" })',
+    )
+
+    expect(findObjectProperty(obj, 'id')).toBeDefined()
+    expect(findObjectProperty(obj, 'message')).toBeDefined()
+    expect(findObjectProperty(obj, 'context')).toBeDefined()
+    expect(findObjectProperty(obj, 'missing')).toBeUndefined()
+  })
+
+  it('should ignore spread elements', () => {
+    const obj = buildObjectExpression('({ ...defaults, message: "Hello" })')
+
+    expect(findObjectProperty(obj, 'id')).toBeUndefined()
+    expect(findObjectProperty(obj, 'message')).toBeDefined()
+  })
+})
 
 describe('buildCalleePath', () => {
   function buildCallExp(code: string) {
diff --git a/src/helpers.ts b/src/helpers.ts
index f50d8af..5845f64 100644
--- a/src/helpers.ts
+++ b/src/helpers.ts
@@ -42,6 +42,13 @@ export const LinguiCallExpressionQuery =
  */
 export const LinguiTransQuery = 'JSXElement[openingElement.name.name=Trans]'
 
+/**
+ * Queries for Lingui ICU components
+ * <Plural>, <SelectOrdinal>, <Select>
+ */
+export const LinguiIcuComponentQuery =
+  ':matches(JSXElement[openingElement.name.name=Plural], JSXElement[openingElement.name.name=SelectOrdinal], JSXElement[openingElement.name.name=Select])'
+
 /**
  * Queries for plural CallExpression expressions and JSX elements
  *
@@ -128,6 +135,43 @@ export function isJSXAttribute(node: TSESTree.Node | undefined): node is TSESTre
   return (node as TSESTree.Node)?.type === TSESTree.AST_NODE_TYPES.JSXAttribute
 }
 
+/**
+ * Find a JSX attribute by name on a JSX element's opening tag.
+ *
+ * @example
+ * // Given `<Trans id="msg.hello" context="greeting">Hello</Trans>`
+ * findJSXAttribute(node, 'id')      // → JSXAttribute node for `id="msg.hello"`
+ * findJSXAttribute(node, 'context') // → JSXAttribute node for `context="greeting"`
+ * findJSXAttribute(node, 'missing') // → undefined
+ */
+export function findJSXAttribute(node: TSESTree.JSXElement, attrName: string) {
+  return node.openingElement.attributes.find(
+    (attr): attr is TSESTree.JSXAttribute =>
+      attr.type === TSESTree.AST_NODE_TYPES.JSXAttribute &&
+      attr.name.type === TSESTree.AST_NODE_TYPES.JSXIdentifier &&
+      attr.name.name === attrName,
+  )
+}
+
+/**
+ * Find a property by name in an object expression.
+ * Handles both identifier keys (`{ id: '...' }`) and string-literal keys (`{ 'id': '...' }`).
+ *
+ * @example
+ * // Given `t({ id: "msg.hello", message: "Hello" })`
+ * findObjectProperty(objectNode, 'id')      // → Property node for `id: "msg.hello"`
+ * findObjectProperty(objectNode, 'message') // → Property node for `message: "Hello"`
+ * findObjectProperty(objectNode, 'missing') // → undefined
+ */
+export function findObjectProperty(object: TSESTree.ObjectExpression, propName: string) {
+  return object.properties.find(
+    (prop): prop is TSESTree.Property =>
+      prop.type === TSESTree.AST_NODE_TYPES.Property &&
+      ((prop.key.type === TSESTree.AST_NODE_TYPES.Identifier && prop.key.name === propName) ||
+        (prop.key.type === TSESTree.AST_NODE_TYPES.Literal && prop.key.value === propName)),
+  )
+}
+
 export function buildCalleePath(node: TSESTree.Expression) {
   let current = node
 
diff --git a/src/index.ts b/src/index.ts
index ea53a81..f16cc3e 100644
--- a/src/index.ts
+++ b/src/index.ts
@@ -8,6 +8,7 @@ import * as noTransInsideTransRule from './rules/no-trans-inside-trans'
 import * as consistentPluralFormatRule from './rules/consistent-plural-format'
 import * as noPluralInsideTransRule from './rules/no-plural-inside-trans'
 import * as requireExplicitIdRule from './rules/require-explicit-id'
+import * as requireImplicitIdRule from './rules/require-implicit-id'
 
 import { ESLint, Linter } from 'eslint'
 import { FlatConfig, RuleModule } from '@typescript-eslint/utils/ts-eslint'
@@ -23,6 +24,7 @@ const rules = {
   [consistentPluralFormatRule.name]: consistentPluralFormatRule.rule,
   [noPluralInsideTransRule.name]: noPluralInsideTransRule.rule,
   [requireExplicitIdRule.name]: requireExplicitIdRule.rule,
+  [requireImplicitIdRule.name]: requireImplicitIdRule.rule,
 }
 
 type RuleKey = keyof typeof rules
diff --git a/src/rules/require-explicit-id.ts b/src/rules/require-explicit-id.ts
index aa335eb..e4a0ebf 100644
--- a/src/rules/require-explicit-id.ts
+++ b/src/rules/require-explicit-id.ts
@@ -1,7 +1,10 @@
 import { TSESTree } from '@typescript-eslint/utils'
 import { createRule } from '../create-rule'
 import {
+  findJSXAttribute,
+  findObjectProperty,
   LinguiCallExpressionQuery,
+  LinguiIcuComponentQuery,
   LinguiTaggedTemplateExpressionMessageQuery,
   LinguiTransQuery,
 } from '../helpers'
@@ -16,11 +19,12 @@ export const rule = createRule<Option[], string>({
   name,
   meta: {
     docs: {
-      description: "enforce 'id' property or attribute for Lingui macros",
+      description: "enforce 'id' property or attribute for Lingui macros and components",
       recommended: 'error',
     },
     messages: {
       default: "Trans component requires an explicit 'id' attribute",
+      missingIdIcu: "Lingui ICU component requires an explicit 'id' attribute",
       missingIdCall: "Macro function call requires an explicit 'id' property",
       noIdInTaggedTemplate:
         "Tagged template literal doesn't support 'id'. Use {{ fn }}({ id: '...', message: '...' }) instead",
@@ -53,9 +57,8 @@ export const rule = createRule<Option[], string>({
       options: [option],
     } = context
 
-    const rulePatterns = option?.patterns?.map(
-      (pattern: string) => new RegExp(pattern, option?.flags),
-    )
+    const flags = option?.flags
+    const rulePatterns = option?.patterns?.map((pattern: string) => new RegExp(pattern, flags))
 
     function validatePattern(node: TSESTree.Node, idValue: string) {
       if (!rulePatterns?.length) {
@@ -71,52 +74,46 @@ export const rule = createRule<Option[], string>({
       }
     }
 
-    return {
-      [LinguiTransQuery](node: TSESTree.JSXElement) {
-        const idAttr = node.openingElement.attributes.find(
-          (attr): attr is TSESTree.JSXAttribute =>
-            attr.type === TSESTree.AST_NODE_TYPES.JSXAttribute &&
-            attr.name.type === TSESTree.AST_NODE_TYPES.JSXIdentifier &&
-            attr.name.name === 'id',
-        )
-
-        if (!idAttr) {
-          context.report({
-            node,
-            messageId: 'default',
-          })
-          return
-        }
+    function checkJSXId(node: TSESTree.JSXElement, missingMessageId: string) {
+      const idAttr = findJSXAttribute(node, 'id')
 
-        // Only validate string literal values; skip complex expressions silently
-        let idValue: string | null = null
-        if (
-          idAttr.value &&
-          idAttr.value.type === TSESTree.AST_NODE_TYPES.Literal &&
-          typeof idAttr.value.value === 'string'
-        ) {
-          idValue = idAttr.value.value
-        } else if (
-          idAttr.value &&
-          idAttr.value.type === TSESTree.AST_NODE_TYPES.JSXExpressionContainer &&
-          idAttr.value.expression.type === TSESTree.AST_NODE_TYPES.Literal &&
-          typeof idAttr.value.expression.value === 'string'
-        ) {
-          // Handle id={"msg.hello"} the same as id="msg.hello"
-          idValue = idAttr.value.expression.value
-        }
+      if (!idAttr) {
+        context.report({ node, messageId: missingMessageId })
+        return
+      }
 
-        if (idValue == null) {
-          return
+      let idValue: string | null = null
+      const attrVal = idAttr.value
+
+      if (attrVal?.type === TSESTree.AST_NODE_TYPES.Literal && typeof attrVal.value === 'string') {
+        idValue = attrVal.value
+      } else if (attrVal?.type === TSESTree.AST_NODE_TYPES.JSXExpressionContainer) {
+        const expr = attrVal.expression
+        if (expr.type === TSESTree.AST_NODE_TYPES.Literal && typeof expr.value === 'string') {
+          idValue = expr.value
         }
+      }
+
+      if (idValue == null) {
+        return
+      }
+
+      validatePattern(idAttr, idValue)
+    }
+
+    return {
+      [LinguiTransQuery](node: TSESTree.JSXElement) {
+        checkJSXId(node, 'default')
+      },
 
-        validatePattern(idAttr, idValue)
+      [LinguiIcuComponentQuery](node: TSESTree.JSXElement) {
+        checkJSXId(node, 'missingIdIcu')
       },
 
       [LinguiTaggedTemplateExpressionMessageQuery](node: TSESTree.TemplateLiteral) {
         const parent = node.parent as TSESTree.TaggedTemplateExpression
-        const fn =
-          parent.tag.type === TSESTree.AST_NODE_TYPES.Identifier ? parent.tag.name : 'function'
+        // The AST query guarantees tag is an Identifier (t, msg, defineMessage)
+        const fn = (parent.tag as TSESTree.Identifier).name
 
         context.report({
           node: parent,
@@ -132,12 +129,7 @@ export const rule = createRule<Option[], string>({
           return
         }
 
-        const idProp = arg.properties.find(
-          (prop): prop is TSESTree.Property =>
-            prop.type === TSESTree.AST_NODE_TYPES.Property &&
-            ((prop.key.type === TSESTree.AST_NODE_TYPES.Identifier && prop.key.name === 'id') ||
-              (prop.key.type === TSESTree.AST_NODE_TYPES.Literal && prop.key.value === 'id')),
-        )
+        const idProp = findObjectProperty(arg, 'id')
 
         if (!idProp) {
           context.report({
diff --git a/src/rules/require-implicit-id.ts b/src/rules/require-implicit-id.ts
new file mode 100644
index 0000000..0e9feba
--- /dev/null
+++ b/src/rules/require-implicit-id.ts
@@ -0,0 +1,64 @@
+import { TSESTree } from '@typescript-eslint/utils'
+import { createRule } from '../create-rule'
+import {
+  findJSXAttribute,
+  findObjectProperty,
+  LinguiCallExpressionQuery,
+  LinguiIcuComponentQuery,
+  LinguiTransQuery,
+} from '../helpers'
+
+export const name = 'require-implicit-id'
+
+export const rule = createRule<[], string>({
+  name,
+  meta: {
+    docs: {
+      description: "forbid explicit 'id' for Lingui macros and components",
+      recommended: 'error',
+    },
+    messages: {
+      forbiddenIdTrans:
+        "<Trans> must not have an explicit 'id' attribute; use auto-generated IDs instead",
+      forbiddenIdIcu:
+        "Lingui ICU component must not have an explicit 'id' attribute; use auto-generated IDs instead",
+      forbiddenIdCall:
+        "Macro function call must not have an explicit 'id' property; use auto-generated IDs instead",
+    },
+    schema: [],
+    type: 'problem' as const,
+  },
+
+  defaultOptions: [],
+
+  create: function (context) {
+    return {
+      [LinguiTransQuery](node: TSESTree.JSXElement) {
+        const idAttr = findJSXAttribute(node, 'id')
+        if (idAttr) {
+          context.report({ node: idAttr, messageId: 'forbiddenIdTrans' })
+        }
+      },
+
+      [LinguiIcuComponentQuery](node: TSESTree.JSXElement) {
+        const idAttr = findJSXAttribute(node, 'id')
+        if (idAttr) {
+          context.report({ node: idAttr, messageId: 'forbiddenIdIcu' })
+        }
+      },
+
+      [LinguiCallExpressionQuery](node: TSESTree.CallExpression) {
+        const arg = node.arguments[0]
+
+        if (!arg || arg.type !== TSESTree.AST_NODE_TYPES.ObjectExpression) {
+          return
+        }
+
+        const idProperty = findObjectProperty(arg, 'id')
+        if (idProperty) {
+          context.report({ node: idProperty, messageId: 'forbiddenIdCall' })
+        }
+      },
+    }
+  },
+})
diff --git a/tests/src/rules/require-explicit-id.test.ts b/tests/src/rules/require-explicit-id.test.ts
index c29544a..cfbac71 100644
--- a/tests/src/rules/require-explicit-id.test.ts
+++ b/tests/src/rules/require-explicit-id.test.ts
@@ -47,6 +47,16 @@ ruleTester.run(name, rule, {
       code: '<Trans id={someVar}>Hello</Trans>',
       options: [{ patterns: ['^msg\\.'] }],
     },
+    // boolean id attribute — silently skipped (no string value to validate)
+    {
+      code: '<Trans id>Hello</Trans>',
+      options: [{ patterns: ['^msg\\.'] }],
+    },
+    // non-string expression — silently skipped
+    {
+      code: '<Trans id={42}>Hello</Trans>',
+      options: [{ patterns: ['^msg\\.'] }],
+    },
     // flags option — case-insensitive match
     {
       code: '<Trans id="MSG.hello">Hello</Trans>',
@@ -99,6 +109,27 @@ ruleTester.run(name, rule, {
       code: "t({ 'id': 'msg.hello', message: 'Hello' })",
       options: [{ patterns: ['^msg\\.'] }],
     },
+
+    // ICU components with id — valid
+    {
+      code: '<Plural id="msg.books" value={count} one="# book" other="# books" />',
+    },
+    {
+      code: '<SelectOrdinal id="msg.order" value={order} one="#st" two="#nd" few="#rd" other="#th" />',
+    },
+    {
+      code: '<Select id="msg.gender" value={gender} male="He" female="She" other="They" />',
+    },
+    // ICU component with patterns — id matches
+    {
+      code: '<Plural id="msg.books" value={count} one="# book" other="# books" />',
+      options: [{ patterns: ['^msg\\.'] }],
+    },
+    // ICU component with expression id and patterns — silently skipped
+    {
+      code: '<Plural id={someVar} value={count} one="# book" other="# books" />',
+      options: [{ patterns: ['^msg\\.'] }],
+    },
   ],
   invalid: [
     // Trans — missing id
@@ -203,5 +234,25 @@ ruleTester.run(name, rule, {
       options: [{ patterns: ['^msg\\.'] }],
       errors: [{ messageId: 'invalidPattern' }],
     },
+
+    // ICU components — missing id
+    {
+      code: '<Plural value={count} one="# book" other="# books" />',
+      errors: [{ messageId: 'missingIdIcu' }],
+    },
+    {
+      code: '<SelectOrdinal value={order} one="#st" two="#nd" few="#rd" other="#th" />',
+      errors: [{ messageId: 'missingIdIcu' }],
+    },
+    {
+      code: '<Select value={gender} male="He" female="She" other="They" />',
+      errors: [{ messageId: 'missingIdIcu' }],
+    },
+    // ICU component — id doesn't match pattern
+    {
+      code: '<Plural id="hello" value={count} one="# book" other="# books" />',
+      options: [{ patterns: ['^msg\\.'] }],
+      errors: [{ messageId: 'invalidPattern' }],
+    },
   ],
 })
diff --git a/tests/src/rules/require-implicit-id.test.ts b/tests/src/rules/require-implicit-id.test.ts
new file mode 100644
index 0000000..975d221
--- /dev/null
+++ b/tests/src/rules/require-implicit-id.test.ts
@@ -0,0 +1,130 @@
+import { rule, name } from '../../../src/rules/require-implicit-id'
+import { RuleTester } from '@typescript-eslint/rule-tester'
+
+describe('', () => {})
+
+const ruleTester = new RuleTester({
+  languageOptions: {
+    parserOptions: {
+      ecmaFeatures: {
+        jsx: true,
+      },
+    },
+  },
+})
+
+ruleTester.run(name, rule, {
+  valid: [
+    // Trans without id — valid
+    {
+      code: '<Trans>Hello</Trans>',
+    },
+    {
+      code: '<Trans render="span">Hello World</Trans>',
+    },
+    {
+      code: `<Trans>
+        Read the <a href="https://lingui.dev">documentation</a>
+        for more info.
+      </Trans>`,
+    },
+
+    // Call expressions without id — valid
+    {
+      code: 't({ message: "Hello" })',
+    },
+    {
+      code: 'msg({ message: "Hello" })',
+    },
+    {
+      code: 'defineMessage({ message: "Hello" })',
+    },
+    // Call expression with no arguments — early return, no error
+    {
+      code: 't()',
+    },
+    // Call expression with non-object argument — early return, no error
+    {
+      code: 't("Hello")',
+    },
+
+    // Tagged templates — always valid
+    {
+      code: 't`Hello`',
+    },
+    {
+      code: 'msg`Hello`',
+    },
+    {
+      code: 'defineMessage`Hello`',
+    },
+
+    // ICU components without id — valid
+    {
+      code: '<Plural value={count} one="# book" other="# books" />',
+    },
+    {
+      code: '<SelectOrdinal value={order} one="#st" two="#nd" few="#rd" other="#th" />',
+    },
+    {
+      code: '<Select value={gender} male="He" female="She" other="They" />',
+    },
+  ],
+  invalid: [
+    // Trans with id — forbidden
+    {
+      code: '<Trans id="msg.hello">Hello</Trans>',
+      errors: [{ messageId: 'forbiddenIdTrans' }],
+    },
+    {
+      code: '<Trans id="msg.greeting" render="span">Hello World</Trans>',
+      errors: [{ messageId: 'forbiddenIdTrans' }],
+    },
+    {
+      code: '<Trans id={"msg.hello"}>Hello</Trans>',
+      errors: [{ messageId: 'forbiddenIdTrans' }],
+    },
+    {
+      code: '<Trans id={someVar}>Hello</Trans>',
+      errors: [{ messageId: 'forbiddenIdTrans' }],
+    },
+
+    // Call expressions with id — forbidden
+    {
+      code: 't({ id: "msg.hello", message: "Hello" })',
+      errors: [{ messageId: 'forbiddenIdCall' }],
+    },
+    {
+      code: 'msg({ id: "msg.hello", message: "Hello" })',
+      errors: [{ messageId: 'forbiddenIdCall' }],
+    },
+    {
+      code: 'defineMessage({ id: "msg.hello", message: "Hello" })',
+      errors: [{ messageId: 'forbiddenIdCall' }],
+    },
+    // String literal key 'id' — still forbidden
+    {
+      code: "t({ 'id': 'msg.hello', message: 'Hello' })",
+      errors: [{ messageId: 'forbiddenIdCall' }],
+    },
+    // Expression id — still forbidden
+    {
+      code: 't({ id: someVar, message: "Hello" })',
+      errors: [{ messageId: 'forbiddenIdCall' }],
+    },
+
+    // ICU components with id — forbidden
+    {
+      code: '<Plural id="msg.books" value={count} one="# book" other="# books" />',
+      errors: [{ messageId: 'forbiddenIdIcu' }],
+    },
+    {
+      code: '<SelectOrdinal id="msg.order" value={order} one="#st" two="#nd" few="#rd" other="#th" />',
+      errors: [{ messageId: 'forbiddenIdIcu' }],
+    },
+    {
+      code: '<Select id="msg.gender" value={gender} male="He" female="She" other="They" />',
+      errors: [{ messageId: 'forbiddenIdIcu' }],
+    },
+  ],
+})