diff --git a/crates/oxc_linter/src/rules/typescript/array_type.rs b/crates/oxc_linter/src/rules/typescript/array_type.rs
index 15772a17e4f40..547292d287066 100644
--- a/crates/oxc_linter/src/rules/typescript/array_type.rs
+++ b/crates/oxc_linter/src/rules/typescript/array_type.rs
@@ -220,6 +220,21 @@ impl Rule for ArrayType {
                     check(param, default_config, readonly_config, ctx);
                 }
             }
+            AstKind::TSConditionalType(ts_conditional_type) => {
+                check(&ts_conditional_type.check_type, default_config, readonly_config, ctx);
+                check(&ts_conditional_type.extends_type, default_config, readonly_config, ctx);
+                check(&ts_conditional_type.true_type, default_config, readonly_config, ctx);
+                check(&ts_conditional_type.false_type, default_config, readonly_config, ctx);
+            }
+            AstKind::TSIndexedAccessType(ts_indexed_access_type) => {
+                check(&ts_indexed_access_type.object_type, default_config, readonly_config, ctx);
+                check(&ts_indexed_access_type.index_type, default_config, readonly_config, ctx);
+            }
+            AstKind::TSMappedType(ts_mapped_type) => {
+                if let Some(type_annotation) = &ts_mapped_type.type_annotation {
+                    check(type_annotation, default_config, readonly_config, ctx);
+                }
+            }
             _ => {}
         }
     }
@@ -890,6 +905,71 @@ fn test() {
             "let a: readonly Array<number>[] = [[]];",
             Some(serde_json::json!([{"default":"generic","readonly":"array"}])),
         ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<string[]>([]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<Array<string>>([]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<string[]>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<Array<{name: string}>>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test = testFn<string[], number[]>([]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test = testFn<Array<string>, Array<number>>([]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<readonly string[]>([]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<ReadonlyArray<string>>([]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<readonly string[]>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<ReadonlyArray<{name: string}>>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<string>('hello');",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test = testFn<{name: string}>({name: 'test'});",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        (
+            "class MyClass<T> { constructor(public value: T) {} }
+const instance = new MyClass<number>(42);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
     ];
 
     let fail = vec![
@@ -1291,6 +1371,99 @@ export const test2 = testFn<readonly string[]>([]);",
 export const test2 = testFn<ReadonlyArray<string>>([]);",
             Some(serde_json::json!([{"default":"array"}])),
         ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test3 = testFn<string[], number[]>([]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test3 = testFn<Array<string>, Array<number>>([]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test4 = testFn<Promise<string[]>>([]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test4 = testFn<Promise<Array<string>>>([]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test5 = testFn<(string & number)[]>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test5 = testFn<(() => void)[]>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        // Array of arrays in generic arguments
+        // Note: When checking types in generic arguments, the rule checks recursively,
+        // so string[][] will trigger errors for both the outer and inner array types.
+        // This is different from checking a standalone type annotation where only the
+        // outermost type is checked.
+        // Class generic instantiation
+        (
+            "class MyClass<T> { constructor(public value: T) {} }
+const instance = new MyClass<number[]>([1, 2, 3]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "class MyClass<T> { constructor(public value: T) {} }
+const instance = new MyClass<Array<number>>([1, 2, 3]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        // Type assertion with generic
+        (
+            "const value = {} as Map<string, number[]>;",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "const value = {} as Map<string, Array<number>>;",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "interface Container<T> { value: T; }
+const container: Container<string[]> = { value: [] };",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "interface Container<T> { value: T; }
+const container: Container<Array<string>> = { value: [] };",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test7 = testFn<readonly string[], readonly number[]>([]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test7 = testFn<ReadonlyArray<string>, ReadonlyArray<number>>([]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test8 = testFn<string[], Array<number>>([]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test8 = testFn<Array<string>, number[]>([]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "type IsArray<T> = T extends any[] ? true : false;",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "type MakeArrays<T> = { [K in keyof T]: T[K][] };",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
     ];
 
     let fix: Vec<(&str, &str, Option<serde_json::Value>)> = vec![
@@ -1865,6 +2038,83 @@ export const test2 = testFn<ReadonlyArray<string>>([]);",
 export const test2 = testFn<readonly string[]>([]);",
             Some(serde_json::json!([{"default":"array"}])),
         ),
+        // Multiple type parameters - fix tests
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test3 = testFn<string[], number[]>([]);",
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test3 = testFn<Array<string>, Array<number>>([]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test3 = testFn<Array<string>, Array<number>>([]);",
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test3 = testFn<string[], number[]>([]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        // Complex types in generic arguments - fix tests
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test5 = testFn<(string & number)[]>([]);",
+            "function testFn<T>(param: T) { return param; }
+export const test5 = testFn<Array<string & number>>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test5 = testFn<(() => void)[]>([]);",
+            "function testFn<T>(param: T) { return param; }
+export const test5 = testFn<Array<() => void>>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        // Note: Nested arrays in generic arguments are checked recursively,
+        // so fixes are applied at each level independently
+        // Class generic instantiation - fix tests
+        (
+            "class MyClass<T> { constructor(public value: T) {} }
+const instance = new MyClass<number[]>([1, 2, 3]);",
+            "class MyClass<T> { constructor(public value: T) {} }
+const instance = new MyClass<Array<number>>([1, 2, 3]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "class MyClass<T> { constructor(public value: T) {} }
+const instance = new MyClass<Array<number>>([1, 2, 3]);",
+            "class MyClass<T> { constructor(public value: T) {} }
+const instance = new MyClass<number[]>([1, 2, 3]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        // Readonly arrays in multiple type parameters - fix tests
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test7 = testFn<readonly string[], readonly number[]>([]);",
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test7 = testFn<ReadonlyArray<string>, ReadonlyArray<number>>([]);",
+            Some(serde_json::json!([{"default":"generic"}])),
+        ),
+        (
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test7 = testFn<ReadonlyArray<string>, ReadonlyArray<number>>([]);",
+            "function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+export const test7 = testFn<readonly string[], readonly number[]>([]);",
+            Some(serde_json::json!([{"default":"array"}])),
+        ),
+        // array-simple with simple types in generics
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test9 = testFn<Array<string>>([]);",
+            "function testFn<T>(param: T) { return param; }
+export const test9 = testFn<string[]>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
+        (
+            "function testFn<T>(param: T) { return param; }
+export const test9 = testFn<ReadonlyArray<number>>([]);",
+            "function testFn<T>(param: T) { return param; }
+export const test9 = testFn<readonly number[]>([]);",
+            Some(serde_json::json!([{"default":"array-simple"}])),
+        ),
     ];
 
     Tester::new(ArrayType::NAME, ArrayType::PLUGIN, pass, fail)
diff --git a/crates/oxc_linter/src/snapshots/typescript_array_type.snap b/crates/oxc_linter/src/snapshots/typescript_array_type.snap
index 79f347487120a..eab2c40805bdb 100644
--- a/crates/oxc_linter/src/snapshots/typescript_array_type.snap
+++ b/crates/oxc_linter/src/snapshots/typescript_array_type.snap
@@ -734,3 +734,191 @@ source: crates/oxc_linter/src/tester.rs
    ·                             ─────────────────────
    ╰────
   help: Replace `ReadonlyArray<string>` with `readonly string[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'string[]' is forbidden. Use 'Array<string>' instead.
+   ╭─[array_type.ts:2:29]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test3 = testFn<string[], number[]>([]);
+   ·                             ────────
+   ╰────
+  help: Replace `string[]` with `Array<string>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'number[]' is forbidden. Use 'Array<number>' instead.
+   ╭─[array_type.ts:2:39]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test3 = testFn<string[], number[]>([]);
+   ·                                       ────────
+   ╰────
+  help: Replace `number[]` with `Array<number>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'Array<string>' is forbidden. Use 'string[]' instead.
+   ╭─[array_type.ts:2:29]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test3 = testFn<Array<string>, Array<number>>([]);
+   ·                             ─────────────
+   ╰────
+  help: Replace `Array<string>` with `string[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'Array<number>' is forbidden. Use 'number[]' instead.
+   ╭─[array_type.ts:2:44]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test3 = testFn<Array<string>, Array<number>>([]);
+   ·                                            ─────────────
+   ╰────
+  help: Replace `Array<number>` with `number[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'string[]' is forbidden. Use 'Array<string>' instead.
+   ╭─[array_type.ts:2:37]
+ 1 │ function testFn<T>(param: T) { return param; }
+ 2 │ export const test4 = testFn<Promise<string[]>>([]);
+   ·                                     ────────
+   ╰────
+  help: Replace `string[]` with `Array<string>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'string[]' is forbidden. Use 'Array<string>' instead.
+   ╭─[array_type.ts:2:37]
+ 1 │ function testFn<T>(param: T) { return param; }
+ 2 │ export const test4 = testFn<Promise<string[]>>([]);
+   ·                                     ────────
+   ╰────
+  help: Replace `string[]` with `Array<string>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'Array<string>' is forbidden. Use 'string[]' instead.
+   ╭─[array_type.ts:2:37]
+ 1 │ function testFn<T>(param: T) { return param; }
+ 2 │ export const test4 = testFn<Promise<Array<string>>>([]);
+   ·                                     ─────────────
+   ╰────
+  help: Replace `Array<string>` with `string[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'Array<string>' is forbidden. Use 'string[]' instead.
+   ╭─[array_type.ts:2:37]
+ 1 │ function testFn<T>(param: T) { return param; }
+ 2 │ export const test4 = testFn<Promise<Array<string>>>([]);
+   ·                                     ─────────────
+   ╰────
+  help: Replace `Array<string>` with `string[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.
+   ╭─[array_type.ts:2:29]
+ 1 │ function testFn<T>(param: T) { return param; }
+ 2 │ export const test5 = testFn<(string & number)[]>([]);
+   ·                             ───────────────────
+   ╰────
+  help: Replace `(string & number)[]` with `Array<string & number>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'T[]' is forbidden for non-simple types. Use 'Array<T>' instead.
+   ╭─[array_type.ts:2:29]
+ 1 │ function testFn<T>(param: T) { return param; }
+ 2 │ export const test5 = testFn<(() => void)[]>([]);
+   ·                             ──────────────
+   ╰────
+  help: Replace `(() => void)[]` with `Array<() => void>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'number[]' is forbidden. Use 'Array<number>' instead.
+   ╭─[array_type.ts:2:30]
+ 1 │ class MyClass<T> { constructor(public value: T) {} }
+ 2 │ const instance = new MyClass<number[]>([1, 2, 3]);
+   ·                              ────────
+   ╰────
+  help: Replace `number[]` with `Array<number>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'Array<number>' is forbidden. Use 'number[]' instead.
+   ╭─[array_type.ts:2:30]
+ 1 │ class MyClass<T> { constructor(public value: T) {} }
+ 2 │ const instance = new MyClass<Array<number>>([1, 2, 3]);
+   ·                              ─────────────
+   ╰────
+  help: Replace `Array<number>` with `number[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'number[]' is forbidden. Use 'Array<number>' instead.
+   ╭─[array_type.ts:1:33]
+ 1 │ const value = {} as Map<string, number[]>;
+   ·                                 ────────
+   ╰────
+  help: Replace `number[]` with `Array<number>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'Array<number>' is forbidden. Use 'number[]' instead.
+   ╭─[array_type.ts:1:33]
+ 1 │ const value = {} as Map<string, Array<number>>;
+   ·                                 ─────────────
+   ╰────
+  help: Replace `Array<number>` with `number[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'string[]' is forbidden. Use 'Array<string>' instead.
+   ╭─[array_type.ts:2:28]
+ 1 │ interface Container<T> { value: T; }
+ 2 │ const container: Container<string[]> = { value: [] };
+   ·                            ────────
+   ╰────
+  help: Replace `string[]` with `Array<string>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'Array<string>' is forbidden. Use 'string[]' instead.
+   ╭─[array_type.ts:2:28]
+ 1 │ interface Container<T> { value: T; }
+ 2 │ const container: Container<Array<string>> = { value: [] };
+   ·                            ─────────────
+   ╰────
+  help: Replace `Array<string>` with `string[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'readonly string[]' is forbidden. Use 'ReadonlyArray<string>' instead.
+   ╭─[array_type.ts:2:29]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test7 = testFn<readonly string[], readonly number[]>([]);
+   ·                             ─────────────────
+   ╰────
+  help: Replace `readonly string[]` with `ReadonlyArray<string>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'readonly number[]' is forbidden. Use 'ReadonlyArray<number>' instead.
+   ╭─[array_type.ts:2:48]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test7 = testFn<readonly string[], readonly number[]>([]);
+   ·                                                ─────────────────
+   ╰────
+  help: Replace `readonly number[]` with `ReadonlyArray<number>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'ReadonlyArray<string>' is forbidden. Use 'readonly string[]' instead.
+   ╭─[array_type.ts:2:29]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test7 = testFn<ReadonlyArray<string>, ReadonlyArray<number>>([]);
+   ·                             ─────────────────────
+   ╰────
+  help: Replace `ReadonlyArray<string>` with `readonly string[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'ReadonlyArray<number>' is forbidden. Use 'readonly number[]' instead.
+   ╭─[array_type.ts:2:52]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test7 = testFn<ReadonlyArray<string>, ReadonlyArray<number>>([]);
+   ·                                                    ─────────────────────
+   ╰────
+  help: Replace `ReadonlyArray<number>` with `readonly number[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'Array<number>' is forbidden. Use 'number[]' instead.
+   ╭─[array_type.ts:2:39]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test8 = testFn<string[], Array<number>>([]);
+   ·                                       ─────────────
+   ╰────
+  help: Replace `Array<number>` with `number[]`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'number[]' is forbidden. Use 'Array<number>' instead.
+   ╭─[array_type.ts:2:44]
+ 1 │ function testFn<T, U>(param1: T, param2: U) { return [param1, param2]; }
+ 2 │ export const test8 = testFn<Array<string>, number[]>([]);
+   ·                                            ────────
+   ╰────
+  help: Replace `number[]` with `Array<number>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'any[]' is forbidden. Use 'Array<any>' instead.
+   ╭─[array_type.ts:1:29]
+ 1 │ type IsArray<T> = T extends any[] ? true : false;
+   ·                             ─────
+   ╰────
+  help: Replace `any[]` with `Array<any>`.
+
+  ⚠ typescript-eslint(array-type): Array type using 'T[]' is forbidden. Use 'Array<T>' instead.
+   ╭─[array_type.ts:1:40]
+ 1 │ type MakeArrays<T> = { [K in keyof T]: T[K][] };
+   ·                                        ──────
+   ╰────
+  help: Replace `T[K][]` with `Array<T[K]>`.