diff --git a/crates/oxc_angular_compiler/src/component/transform.rs b/crates/oxc_angular_compiler/src/component/transform.rs
index 954ad387b..10290cde5 100644
--- a/crates/oxc_angular_compiler/src/component/transform.rs
+++ b/crates/oxc_angular_compiler/src/component/transform.rs
@@ -38,6 +38,7 @@ use crate::directive::{
     extract_content_queries, extract_directive_metadata, extract_view_queries,
     find_directive_decorator_span, generate_directive_definitions,
 };
+use crate::dts;
 use crate::injectable::{
     extract_injectable_metadata, find_injectable_decorator_span,
     generate_injectable_definition_from_decorator,
@@ -276,6 +277,20 @@ pub struct TransformResult {
 
     /// Number of components found in the file.
     pub component_count: usize,
+
+    /// `.d.ts` type declarations for Angular classes.
+    ///
+    /// Each entry contains the class name and the static member declarations
+    /// that should be injected into the corresponding `.d.ts` class body.
+    /// This enables library builds to include proper Ivy type declarations
+    /// for template type-checking by consumers.
+    ///
+    /// The declarations use `i0` as the namespace alias for `@angular/core`.
+    /// Consumers must ensure their `.d.ts` files include:
+    /// ```typescript
+    /// import * as i0 from "@angular/core";
+    /// ```
+    pub dts_declarations: Vec<crate::dts::DtsDeclaration>,
 }
 
 impl TransformResult {
@@ -1565,6 +1580,11 @@ pub fn transform_angular_file(
                     // Signal-based queries (contentChild(), contentChildren()) are also detected here
                     let content_queries = extract_content_queries(allocator, class);
 
+                    // Collect content query property names for .d.ts generation
+                    // (before content_queries is moved into compile_component_full)
+                    let content_query_names: Vec<String> =
+                        content_queries.iter().map(|q| q.property_name.to_string()).collect();
+
                     // 4. Compile the template and generate ɵcmp/ɵfac
                     // Pass the shared pool index to ensure unique constant names
                     // Pass the file-level namespace registry to ensure consistent namespace assignments
@@ -1617,15 +1637,14 @@ pub fn transform_angular_file(
 
                             // Check if the class also has an @Injectable decorator.
                             // @Injectable is SHARED precedence and can coexist with @Component.
-                            if let Some(injectable_metadata) =
-                                extract_injectable_metadata(allocator, class)
-                            {
+                            let has_injectable = extract_injectable_metadata(allocator, class);
+                            if let Some(injectable_metadata) = &has_injectable {
                                 if let Some(span) = find_injectable_decorator_span(class) {
                                     decorator_spans_to_remove.push(span);
                                 }
                                 if let Some(inj_def) = generate_injectable_definition_from_decorator(
                                     allocator,
-                                    &injectable_metadata,
+                                    injectable_metadata,
                                 ) {
                                     let emitter = JsEmitter::new();
                                     property_assignments.push_str(&format!(
@@ -1634,6 +1653,7 @@ pub fn transform_angular_file(
                                     ));
                                 }
                             }
+                            let has_injectable = has_injectable.is_some();
 
                             // Split declarations into two groups:
                             // 1. decls_before_class: child view functions, constants (needed BEFORE class)
@@ -1736,6 +1756,19 @@ pub fn transform_angular_file(
                                 result.dependencies.push(style_url.to_string());
                             }
 
+                            // Generate .d.ts type declaration for this component
+                            let type_argument_count = class
+                                .type_parameters
+                                .as_ref()
+                                .map_or(0, |tp| tp.params.len() as u32);
+                            result.dts_declarations.push(dts::generate_component_dts(
+                                &metadata,
+                                type_argument_count,
+                                &content_query_names,
+                                has_injectable,
+                                &compilation_result.ng_content_selectors,
+                            ));
+
                             result.component_count += 1;
                         }
                         Err(diags) => {
@@ -1814,14 +1847,14 @@ pub fn transform_angular_file(
 
                     // Check if the class also has an @Injectable decorator.
                     // @Injectable is SHARED precedence and can coexist with @Directive.
-                    if let Some(injectable_metadata) = extract_injectable_metadata(allocator, class)
-                    {
+                    let has_injectable = extract_injectable_metadata(allocator, class);
+                    if let Some(injectable_metadata) = &has_injectable {
                         if let Some(span) = find_injectable_decorator_span(class) {
                             decorator_spans_to_remove.push(span);
                         }
                         if let Some(inj_def) = generate_injectable_definition_from_decorator(
                             allocator,
-                            &injectable_metadata,
+                            injectable_metadata,
                         ) {
                             property_assignments.push_str(&format!(
                                 "\nstatic ɵprov = {};",
@@ -1829,6 +1862,15 @@ pub fn transform_angular_file(
                             ));
                         }
                     }
+                    let has_injectable = has_injectable.is_some();
+
+                    // Generate .d.ts type declaration for this directive
+                    let type_argument_count =
+                        class.type_parameters.as_ref().map_or(0, |tp| tp.params.len() as u32);
+                    directive_metadata.type_argument_count = type_argument_count;
+                    result
+                        .dts_declarations
+                        .push(dts::generate_directive_dts(&directive_metadata, has_injectable));
 
                     class_positions.push((
                         class_name.clone(),
@@ -1879,15 +1921,14 @@ pub fn transform_angular_file(
 
                         // Check if the class also has an @Injectable decorator (issue #65).
                         // @Injectable is SHARED precedence and can coexist with @Pipe.
-                        if let Some(injectable_metadata) =
-                            extract_injectable_metadata(allocator, class)
-                        {
+                        let has_injectable = extract_injectable_metadata(allocator, class);
+                        if let Some(injectable_metadata) = &has_injectable {
                             if let Some(span) = find_injectable_decorator_span(class) {
                                 decorator_spans_to_remove.push(span);
                             }
                             if let Some(inj_def) = generate_injectable_definition_from_decorator(
                                 allocator,
-                                &injectable_metadata,
+                                injectable_metadata,
                             ) {
                                 property_assignments.push_str(&format!(
                                     "\nstatic ɵprov = {};",
@@ -1895,6 +1936,16 @@ pub fn transform_angular_file(
                                 ));
                             }
                         }
+                        let has_injectable = has_injectable.is_some();
+
+                        // Generate .d.ts type declaration for this pipe
+                        let type_argument_count =
+                            class.type_parameters.as_ref().map_or(0, |tp| tp.params.len() as u32);
+                        result.dts_declarations.push(dts::generate_pipe_dts(
+                            &pipe_metadata,
+                            type_argument_count,
+                            has_injectable,
+                        ));
 
                         class_positions.push((
                             class_name.clone(),
@@ -1951,15 +2002,14 @@ pub fn transform_angular_file(
 
                         // Check if the class also has an @Injectable decorator.
                         // @Injectable is SHARED precedence and can coexist with @NgModule.
-                        if let Some(injectable_metadata) =
-                            extract_injectable_metadata(allocator, class)
-                        {
+                        let has_injectable = extract_injectable_metadata(allocator, class);
+                        if let Some(injectable_metadata) = &has_injectable {
                             if let Some(span) = find_injectable_decorator_span(class) {
                                 decorator_spans_to_remove.push(span);
                             }
                             if let Some(inj_def) = generate_injectable_definition_from_decorator(
                                 allocator,
-                                &injectable_metadata,
+                                injectable_metadata,
                             ) {
                                 property_assignments.push_str(&format!(
                                     "\nstatic ɵprov = {};",
@@ -1967,6 +2017,7 @@ pub fn transform_angular_file(
                                 ));
                             }
                         }
+                        let has_injectable = has_injectable.is_some();
 
                         // Collect any side-effect statements as external declarations
                         let mut external_decls = String::new();
@@ -1977,6 +2028,15 @@ pub fn transform_angular_file(
                             external_decls.push_str(&emitter.emit_statement(stmt));
                         }
 
+                        // Generate .d.ts type declaration for this NgModule
+                        let type_argument_count =
+                            class.type_parameters.as_ref().map_or(0, |tp| tp.params.len() as u32);
+                        result.dts_declarations.push(dts::generate_ng_module_dts(
+                            &ng_module_metadata,
+                            type_argument_count,
+                            has_injectable,
+                        ));
+
                         // NgModule: external_decls go AFTER the class (they reference the class name)
                         class_positions.push((
                             class_name.clone(),
@@ -2028,6 +2088,14 @@ pub fn transform_angular_file(
                             emitter.emit_expression(&definition.prov_definition)
                         );
 
+                        // Generate .d.ts type declaration for this injectable
+                        let type_argument_count =
+                            class.type_parameters.as_ref().map_or(0, |tp| tp.params.len() as u32);
+                        result.dts_declarations.push(dts::generate_injectable_dts(
+                            &injectable_metadata,
+                            type_argument_count,
+                        ));
+
                         class_positions.push((
                             class_name.clone(),
                             compute_effective_start(class, &decorator_spans_to_remove, stmt_start),
@@ -2172,6 +2240,9 @@ struct FullCompilationResult {
     /// The next constant pool index to use for the next component.
     /// This is used to share pool state across multiple components in the same file.
     next_pool_index: u32,
+
+    /// The ng-content selectors found in the template (e.g., `["*", ".header"]`).
+    ng_content_selectors: Vec<String>,
 }
 
 /// Compile a component template and generate ɵcmp/ɵfac definitions.
@@ -2246,6 +2317,10 @@ fn compile_component_full<'a>(
         return Err(diagnostics);
     }
 
+    // Capture ng-content selectors from the R3 AST for .d.ts generation
+    let ng_content_selectors: Vec<String> =
+        r3_result.ng_content_selectors.iter().map(|s| s.to_string()).collect();
+
     // Merge inline template styles into component metadata
     // These are styles from <style> tags directly in the template HTML
     for style in r3_result.styles.iter() {
@@ -2486,6 +2561,7 @@ fn compile_component_full<'a>(
         hmr_initializer_js,
         class_debug_info_js,
         next_pool_index,
+        ng_content_selectors,
     })
 }
 
diff --git a/crates/oxc_angular_compiler/src/dts.rs b/crates/oxc_angular_compiler/src/dts.rs
new file mode 100644
index 000000000..1201ce729
--- /dev/null
+++ b/crates/oxc_angular_compiler/src/dts.rs
@@ -0,0 +1,768 @@
+//! Angular `.d.ts` type declaration generation.
+//!
+//! This module generates the static type declarations that should be added
+//! to `.d.ts` files for Angular library builds. These declarations enable
+//! Angular's template type-checking system to work with pre-compiled libraries.
+//!
+//! The generated declarations use `i0` as the namespace alias for `@angular/core`,
+//! matching Angular's convention. Consumers must ensure their `.d.ts` files include:
+//! ```typescript
+//! import * as i0 from "@angular/core";
+//! ```
+//!
+//! Reference: Angular's `IvyDeclarationDtsTransform` in
+//! `packages/compiler-cli/src/ngtsc/transform/src/declaration.ts`
+
+use crate::component::{ComponentMetadata, HostDirectiveMetadata, R3DependencyMetadata};
+use crate::directive::{R3DirectiveMetadata, R3InputMetadata};
+use crate::injectable::InjectableMetadata;
+use crate::ng_module::NgModuleMetadata;
+use crate::pipe::PipeMetadata;
+
+/// A `.d.ts` type declaration for an Angular class.
+///
+/// Contains the class name and the static member declarations
+/// that should be injected into the corresponding `.d.ts` class.
+#[derive(Debug, Clone, Default)]
+pub struct DtsDeclaration {
+    /// The name of the class.
+    pub class_name: String,
+    /// The static member declarations to add to the class body in `.d.ts`.
+    /// This is a newline-separated string of `static` property declarations.
+    ///
+    /// Example:
+    /// ```text
+    /// static ɵfac: i0.ɵɵFactoryDeclaration<MyComponent, never>;
+    /// static ɵcmp: i0.ɵɵComponentDeclaration<MyComponent, "app-my", never, {}, {}, never, never, true, never>;
+    /// ```
+    pub members: String,
+}
+
+// =============================================================================
+// Component Declarations
+// =============================================================================
+
+/// Generate `.d.ts` declarations for a `@Component` class.
+///
+/// Produces:
+/// - `static ɵfac: i0.ɵɵFactoryDeclaration<T, CtorDeps>;`
+/// - `static ɵcmp: i0.ɵɵComponentDeclaration<T, Selector, ExportAs, InputMap, OutputMap, QueryFields, NgContentSelectors, IsStandalone, HostDirectives, IsSignal>;`
+pub fn generate_component_dts(
+    metadata: &ComponentMetadata,
+    type_argument_count: u32,
+    content_query_names: &[String],
+    has_injectable: bool,
+    ng_content_selectors: &[String],
+) -> DtsDeclaration {
+    let class_name = metadata.class_name.as_str();
+    let type_with_params = type_with_parameters(class_name, type_argument_count);
+
+    // ɵfac declaration
+    let ctor_deps_type = generate_ctor_deps_type_from_component_deps(
+        metadata.constructor_deps.as_ref().map(|v| v.as_slice() as &[R3DependencyMetadata]),
+    );
+    let fac =
+        format!("static ɵfac: i0.ɵɵFactoryDeclaration<{type_with_params}, {ctor_deps_type}>;");
+
+    // ɵcmp declaration
+    let selector = match &metadata.selector {
+        Some(s) => {
+            // Remove newlines from selector (matching Angular TS behavior)
+            let cleaned = s.as_str().replace('\n', "");
+            format!("\"{}\"", escape_dts_string(&cleaned))
+        }
+        None => "never".to_string(),
+    };
+
+    let export_as = if metadata.export_as.is_empty() {
+        "never".to_string()
+    } else {
+        format!(
+            "[{}]",
+            metadata
+                .export_as
+                .iter()
+                .map(|e| format!("\"{}\"", escape_dts_string(e.as_str())))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+
+    let input_map = generate_input_map_type(&metadata.inputs);
+    let output_map = generate_output_map_type(&metadata.outputs);
+
+    let query_fields = if content_query_names.is_empty() {
+        "never".to_string()
+    } else {
+        format!(
+            "[{}]",
+            content_query_names
+                .iter()
+                .map(|name| format!("\"{}\"", escape_dts_string(name)))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+
+    // NgContentSelectors: format as tuple type from template ng-content selectors
+    let ng_content_selectors = if ng_content_selectors.is_empty() {
+        "never".to_string()
+    } else {
+        format!(
+            "[{}]",
+            ng_content_selectors
+                .iter()
+                .map(|s| format!("\"{}\"", escape_dts_string(s)))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+
+    let is_standalone = if metadata.standalone { "true" } else { "false" };
+
+    let host_directives = if metadata.host_directives.is_empty() {
+        "never".to_string()
+    } else {
+        generate_host_directives_type_from_component(&metadata.host_directives)
+    };
+
+    let mut type_params = vec![
+        type_with_params.clone(),
+        selector,
+        export_as,
+        input_map,
+        output_map,
+        query_fields,
+        ng_content_selectors,
+        is_standalone.to_string(),
+        host_directives,
+    ];
+
+    if metadata.is_signal {
+        type_params.push("true".to_string());
+    }
+
+    let cmp = format!("static ɵcmp: i0.ɵɵComponentDeclaration<{}>;", type_params.join(", "));
+
+    let mut members = format!("{fac}\n{cmp}");
+
+    // Add ɵprov if @Injectable is also present
+    if has_injectable {
+        members
+            .push_str(&format!("\nstatic ɵprov: i0.ɵɵInjectableDeclaration<{type_with_params}>;"));
+    }
+
+    // Add ngAcceptInputType_* fields for non-signal inputs with transform functions
+    generate_input_transform_fields(&metadata.inputs, &mut members);
+
+    DtsDeclaration { class_name: class_name.to_string(), members }
+}
+
+// =============================================================================
+// Directive Declarations
+// =============================================================================
+
+/// Generate `.d.ts` declarations for a `@Directive` class.
+///
+/// Produces:
+/// - `static ɵfac: i0.ɵɵFactoryDeclaration<T, CtorDeps>;`
+/// - `static ɵdir: i0.ɵɵDirectiveDeclaration<T, Selector, ExportAs, InputMap, OutputMap, QueryFields, never, IsStandalone, HostDirectives, IsSignal>;`
+pub fn generate_directive_dts(
+    metadata: &R3DirectiveMetadata,
+    has_injectable: bool,
+) -> DtsDeclaration {
+    let class_name = metadata.name.as_str();
+    let type_with_params = type_with_parameters(class_name, metadata.type_argument_count);
+
+    // ɵfac declaration
+    let ctor_deps_type =
+        generate_ctor_deps_type_from_factory_deps(metadata.deps.as_ref().map(|v| v.as_slice()));
+    let fac =
+        format!("static ɵfac: i0.ɵɵFactoryDeclaration<{type_with_params}, {ctor_deps_type}>;");
+
+    // ɵdir declaration
+    let selector = match &metadata.selector {
+        Some(s) => {
+            let cleaned = s.as_str().replace('\n', "");
+            format!("\"{}\"", escape_dts_string(&cleaned))
+        }
+        None => "never".to_string(),
+    };
+
+    let export_as = if metadata.export_as.is_empty() {
+        "never".to_string()
+    } else {
+        format!(
+            "[{}]",
+            metadata
+                .export_as
+                .iter()
+                .map(|e| format!("\"{}\"", escape_dts_string(e.as_str())))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+
+    let input_map = generate_input_map_type(&metadata.inputs);
+    let output_map = generate_output_map_type(&metadata.outputs);
+
+    let query_fields = if metadata.queries.is_empty() {
+        "never".to_string()
+    } else {
+        format!(
+            "[{}]",
+            metadata
+                .queries
+                .iter()
+                .map(|q| format!("\"{}\"", escape_dts_string(q.property_name.as_str())))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+
+    // NgContentSelectors is always `never` for directives
+    let ng_content_selectors = "never";
+
+    let is_standalone = if metadata.is_standalone { "true" } else { "false" };
+
+    let host_directives = if metadata.host_directives.is_empty() {
+        "never".to_string()
+    } else {
+        generate_host_directives_type_from_directive(&metadata.host_directives)
+    };
+
+    let mut type_params = vec![
+        type_with_params.clone(),
+        selector,
+        export_as,
+        input_map,
+        output_map,
+        query_fields,
+        ng_content_selectors.to_string(),
+        is_standalone.to_string(),
+        host_directives,
+    ];
+
+    if metadata.is_signal {
+        type_params.push("true".to_string());
+    }
+
+    let dir = format!("static ɵdir: i0.ɵɵDirectiveDeclaration<{}>;", type_params.join(", "));
+
+    let mut members = format!("{fac}\n{dir}");
+
+    if has_injectable {
+        members
+            .push_str(&format!("\nstatic ɵprov: i0.ɵɵInjectableDeclaration<{type_with_params}>;"));
+    }
+
+    // Add ngAcceptInputType_* fields for non-signal inputs with transform functions
+    generate_input_transform_fields(&metadata.inputs, &mut members);
+
+    DtsDeclaration { class_name: class_name.to_string(), members }
+}
+
+// =============================================================================
+// Pipe Declarations
+// =============================================================================
+
+/// Generate `.d.ts` declarations for a `@Pipe` class.
+///
+/// Produces:
+/// - `static ɵfac: i0.ɵɵFactoryDeclaration<T, CtorDeps>;`
+/// - `static ɵpipe: i0.ɵɵPipeDeclaration<T, Name, IsStandalone>;`
+pub fn generate_pipe_dts(
+    metadata: &PipeMetadata,
+    type_argument_count: u32,
+    has_injectable: bool,
+) -> DtsDeclaration {
+    let class_name = metadata.class_name.as_str();
+    let type_with_params = type_with_parameters(class_name, type_argument_count);
+
+    // ɵfac declaration
+    let ctor_deps_type =
+        generate_ctor_deps_type_from_factory_deps(metadata.deps.as_ref().map(|v| v.as_slice()));
+    let fac =
+        format!("static ɵfac: i0.ɵɵFactoryDeclaration<{type_with_params}, {ctor_deps_type}>;");
+
+    // ɵpipe declaration
+    let pipe_name = match &metadata.pipe_name {
+        Some(name) => format!("\"{}\"", escape_dts_string(name.as_str())),
+        None => "null".to_string(),
+    };
+
+    let is_standalone = if metadata.standalone { "true" } else { "false" };
+
+    let pipe = format!(
+        "static ɵpipe: i0.ɵɵPipeDeclaration<{type_with_params}, {pipe_name}, {is_standalone}>;"
+    );
+
+    let mut members = format!("{fac}\n{pipe}");
+
+    if has_injectable {
+        members
+            .push_str(&format!("\nstatic ɵprov: i0.ɵɵInjectableDeclaration<{type_with_params}>;"));
+    }
+
+    DtsDeclaration { class_name: class_name.to_string(), members }
+}
+
+// =============================================================================
+// NgModule Declarations
+// =============================================================================
+
+/// Generate `.d.ts` declarations for a `@NgModule` class.
+///
+/// Produces:
+/// - `static ɵfac: i0.ɵɵFactoryDeclaration<T, CtorDeps>;`
+/// - `static ɵmod: i0.ɵɵNgModuleDeclaration<T, Declarations, Imports, Exports>;`
+/// - `static ɵinj: i0.ɵɵInjectorDeclaration<T>;`
+pub fn generate_ng_module_dts(
+    metadata: &NgModuleMetadata,
+    type_argument_count: u32,
+    has_injectable: bool,
+) -> DtsDeclaration {
+    let class_name = metadata.class_name.as_str();
+    let type_with_params = type_with_parameters(class_name, type_argument_count);
+
+    // ɵfac declaration
+    let ctor_deps_type =
+        generate_ctor_deps_type_from_factory_deps(metadata.deps.as_ref().map(|v| v.as_slice()));
+    let fac =
+        format!("static ɵfac: i0.ɵɵFactoryDeclaration<{type_with_params}, {ctor_deps_type}>;");
+
+    // ɵmod declaration - uses typeof references for declarations/imports/exports
+    let declarations_type = if metadata.declarations.is_empty() {
+        "never".to_string()
+    } else {
+        format!(
+            "[{}]",
+            metadata
+                .declarations
+                .iter()
+                .map(|d| format!("typeof {}", d.as_str()))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+
+    let imports_type = if metadata.imports.is_empty() {
+        "never".to_string()
+    } else {
+        format!(
+            "[{}]",
+            metadata
+                .imports
+                .iter()
+                .map(|i| format!("typeof {}", i.as_str()))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+
+    let exports_type = if metadata.exports.is_empty() {
+        "never".to_string()
+    } else {
+        format!(
+            "[{}]",
+            metadata
+                .exports
+                .iter()
+                .map(|e| format!("typeof {}", e.as_str()))
+                .collect::<Vec<_>>()
+                .join(", ")
+        )
+    };
+
+    let mod_decl = format!(
+        "static ɵmod: i0.ɵɵNgModuleDeclaration<{type_with_params}, {declarations_type}, {imports_type}, {exports_type}>;"
+    );
+
+    // ɵinj declaration
+    let inj = format!("static ɵinj: i0.ɵɵInjectorDeclaration<{type_with_params}>;");
+
+    let mut members = format!("{fac}\n{mod_decl}\n{inj}");
+
+    if has_injectable {
+        members
+            .push_str(&format!("\nstatic ɵprov: i0.ɵɵInjectableDeclaration<{type_with_params}>;"));
+    }
+
+    DtsDeclaration { class_name: class_name.to_string(), members }
+}
+
+// =============================================================================
+// Injectable Declarations
+// =============================================================================
+
+/// Generate `.d.ts` declarations for a standalone `@Injectable` class.
+///
+/// Produces:
+/// - `static ɵfac: i0.ɵɵFactoryDeclaration<T, CtorDeps>;`
+/// - `static ɵprov: i0.ɵɵInjectableDeclaration<T>;`
+pub fn generate_injectable_dts(
+    metadata: &InjectableMetadata,
+    type_argument_count: u32,
+) -> DtsDeclaration {
+    let class_name = metadata.class_name.as_str();
+    let type_with_params = type_with_parameters(class_name, type_argument_count);
+
+    // ɵfac declaration
+    let ctor_deps_type =
+        generate_ctor_deps_type_from_factory_deps(metadata.deps.as_ref().map(|v| v.as_slice()));
+    let fac =
+        format!("static ɵfac: i0.ɵɵFactoryDeclaration<{type_with_params}, {ctor_deps_type}>;");
+
+    // ɵprov declaration
+    let prov = format!("static ɵprov: i0.ɵɵInjectableDeclaration<{type_with_params}>;");
+
+    let members = format!("{fac}\n{prov}");
+
+    DtsDeclaration { class_name: class_name.to_string(), members }
+}
+
+// =============================================================================
+// Helper Functions
+// =============================================================================
+
+/// Generate the type parameter `T` with any generic params filled as `any`.
+///
+/// For `class Foo<A, B>`, produces `Foo<any, any>`.
+/// For `class Foo`, produces `Foo`.
+fn type_with_parameters(class_name: &str, count: u32) -> String {
+    if count == 0 {
+        class_name.to_string()
+    } else {
+        let params: Vec<&str> = (0..count).map(|_| "any").collect();
+        format!("{}<{}>", class_name, params.join(", "))
+    }
+}
+
+/// Shared helper: given an iterator of per-dependency info tuples, produce the
+/// constructor deps type string (`never` or a tuple type like
+/// `[null, {attribute: "title", optional: true}, null]`).
+///
+/// Each tuple element is `(attribute_entry, optional, host, self_, skip_self)`.
+/// `attribute_entry` is the pre-formatted `attribute: …` string fragment when
+/// the dependency has an attribute flag (e.g. `attribute: "title"` or
+/// `attribute: string`), or `None` otherwise.
+fn generate_ctor_deps_type(
+    deps: impl Iterator<Item = (Option<String>, bool, bool, bool, bool)>,
+) -> String {
+    let dep_types: Vec<Option<String>> = deps
+        .map(|(attribute_entry, optional, host, self_, skip_self)| {
+            let mut entries: Vec<String> = Vec::new();
+            if let Some(attr) = attribute_entry {
+                entries.push(attr);
+            }
+            if optional {
+                entries.push("optional: true".to_string());
+            }
+            if host {
+                entries.push("host: true".to_string());
+            }
+            if self_ {
+                entries.push("self: true".to_string());
+            }
+            if skip_self {
+                entries.push("skipSelf: true".to_string());
+            }
+            if entries.is_empty() { None } else { Some(format!("{{ {} }}", entries.join(", "))) }
+        })
+        .collect();
+
+    let has_types = dep_types.iter().any(|t| t.is_some());
+    if !has_types {
+        "never".to_string()
+    } else {
+        let entries: Vec<String> =
+            dep_types.into_iter().map(|t| t.unwrap_or_else(|| "null".to_string())).collect();
+        format!("[{}]", entries.join(", "))
+    }
+}
+
+/// Generate the constructor deps type parameter for `ɵɵFactoryDeclaration`.
+///
+/// Returns `never` if no dependency has any special flags (attribute, optional, host, self, skipSelf).
+/// Otherwise returns a tuple type like `[null, {attribute: "title", optional: true}, null]`.
+fn generate_ctor_deps_type_from_component_deps(deps: Option<&[R3DependencyMetadata]>) -> String {
+    match deps {
+        None => "never".to_string(),
+        Some(deps) => generate_ctor_deps_type(deps.iter().map(|d| {
+            let attribute_entry = d
+                .attribute_name
+                .as_ref()
+                .map(|name| format!("attribute: \"{}\"", escape_dts_string(name.as_str())));
+            (attribute_entry, d.optional, d.host, d.self_, d.skip_self)
+        })),
+    }
+}
+
+/// Generate the constructor deps type from directive/pipe/ngmodule/injectable deps.
+///
+/// Uses the factory module's `R3DependencyMetadata` which is used by directives,
+/// pipes, NgModules, and injectables.
+///
+/// Returns `never` if no dependency has any special flags (attribute, optional, host, self, skipSelf).
+/// Otherwise returns a tuple type like `[null, {attribute: string, optional: true}, null]`.
+fn generate_ctor_deps_type_from_factory_deps(
+    deps: Option<&[crate::factory::R3DependencyMetadata]>,
+) -> String {
+    match deps {
+        None => "never".to_string(),
+        Some(deps) => generate_ctor_deps_type(deps.iter().map(|d| {
+            let attribute_entry = if d.attribute_name_type.is_some() {
+                Some("attribute: string".to_string())
+            } else {
+                None
+            };
+            (attribute_entry, d.optional, d.host, d.self_, d.skip_self)
+        })),
+    }
+}
+
+/// Generate `ngAcceptInputType_*` static fields for non-signal inputs with transform functions.
+///
+/// When an input has a `transform` function (e.g., `@Input({transform: booleanAttribute})`),
+/// Angular generates a static field like:
+/// ```text
+/// static ngAcceptInputType_disabled: unknown;
+/// ```
+/// This enables template type-checking to know that transformed inputs accept wider types.
+///
+/// Signal inputs do NOT generate these fields (they capture WriteT within the InputSignal type).
+///
+/// Note: We use `unknown` as the type because we don't have access to the TypeScript type checker
+/// to determine the actual write type of the transform function.
+fn generate_input_transform_fields(inputs: &[R3InputMetadata], members: &mut String) {
+    for input in inputs {
+        if !input.is_signal && input.transform_function.is_some() {
+            members.push_str(&format!(
+                "\nstatic ngAcceptInputType_{}: unknown;",
+                input.class_property_name.as_str()
+            ));
+        }
+    }
+}
+
+/// Generate the input map type for `ɵɵComponentDeclaration` / `ɵɵDirectiveDeclaration`.
+///
+/// Produces a TypeScript object literal type like:
+/// ```text
+/// { "name": { "alias": "name"; "required": false; }; "value": { "alias": "aliasedValue"; "required": true; "isSignal": true; }; }
+/// ```
+fn generate_input_map_type(inputs: &[R3InputMetadata]) -> String {
+    if inputs.is_empty() {
+        return "{}".to_string();
+    }
+
+    let entries: Vec<String> = inputs
+        .iter()
+        .map(|input| {
+            let key = escape_dts_string(input.class_property_name.as_str());
+            let alias = escape_dts_string(input.binding_property_name.as_str());
+            let required = if input.required { "true" } else { "false" };
+
+            let mut props = format!("\"alias\": \"{alias}\"; \"required\": {required};");
+            if input.is_signal {
+                props.push_str(" \"isSignal\": true;");
+            }
+
+            format!("\"{key}\": {{ {props} }};")
+        })
+        .collect();
+
+    format!("{{ {} }}", entries.join(" "))
+}
+
+/// Generate the output map type.
+///
+/// Produces: `{ "clicked": "clicked"; "valueChanged": "onChange"; }`
+fn generate_output_map_type(outputs: &[(oxc_span::Atom, oxc_span::Atom)]) -> String {
+    if outputs.is_empty() {
+        return "{}".to_string();
+    }
+
+    let entries: Vec<String> = outputs
+        .iter()
+        .map(|(class_name, binding_name)| {
+            format!(
+                "\"{}\": \"{}\";",
+                escape_dts_string(class_name.as_str()),
+                escape_dts_string(binding_name.as_str())
+            )
+        })
+        .collect();
+
+    format!("{{ {} }}", entries.join(" "))
+}
+
+/// Generate the host directives type from component host directives.
+fn generate_host_directives_type_from_component(
+    host_directives: &[HostDirectiveMetadata],
+) -> String {
+    let entries: Vec<String> = host_directives
+        .iter()
+        .map(|hd| {
+            let directive = format!("typeof {}", hd.directive.as_str());
+            let inputs = if hd.inputs.is_empty() {
+                "{}".to_string()
+            } else {
+                let input_entries: Vec<String> = hd
+                    .inputs
+                    .iter()
+                    .map(|(public, internal)| {
+                        format!(
+                            "\"{}\": \"{}\"",
+                            escape_dts_string(public.as_str()),
+                            escape_dts_string(internal.as_str())
+                        )
+                    })
+                    .collect();
+                format!("{{ {} }}", input_entries.join("; "))
+            };
+            let outputs = if hd.outputs.is_empty() {
+                "{}".to_string()
+            } else {
+                let output_entries: Vec<String> = hd
+                    .outputs
+                    .iter()
+                    .map(|(public, internal)| {
+                        format!(
+                            "\"{}\": \"{}\"",
+                            escape_dts_string(public.as_str()),
+                            escape_dts_string(internal.as_str())
+                        )
+                    })
+                    .collect();
+                format!("{{ {} }}", output_entries.join("; "))
+            };
+            format!("{{ directive: {directive}; inputs: {inputs}; outputs: {outputs}; }}")
+        })
+        .collect();
+
+    format!("[{}]", entries.join(", "))
+}
+
+/// Generate the host directives type from directive host directives.
+fn generate_host_directives_type_from_directive(
+    host_directives: &[crate::directive::R3HostDirectiveMetadata],
+) -> String {
+    let entries: Vec<String> = host_directives
+        .iter()
+        .map(|hd| {
+            // Extract the directive name from the OutputExpression
+            let directive_name = extract_directive_name_from_expr(&hd.directive);
+            let directive = format!("typeof {directive_name}");
+            let inputs = if hd.inputs.is_empty() {
+                "{}".to_string()
+            } else {
+                let input_entries: Vec<String> = hd
+                    .inputs
+                    .iter()
+                    .map(|(public, internal)| {
+                        format!(
+                            "\"{}\": \"{}\"",
+                            escape_dts_string(public.as_str()),
+                            escape_dts_string(internal.as_str())
+                        )
+                    })
+                    .collect();
+                format!("{{ {} }}", input_entries.join("; "))
+            };
+            let outputs = if hd.outputs.is_empty() {
+                "{}".to_string()
+            } else {
+                let output_entries: Vec<String> = hd
+                    .outputs
+                    .iter()
+                    .map(|(public, internal)| {
+                        format!(
+                            "\"{}\": \"{}\"",
+                            escape_dts_string(public.as_str()),
+                            escape_dts_string(internal.as_str())
+                        )
+                    })
+                    .collect();
+                format!("{{ {} }}", output_entries.join("; "))
+            };
+            format!("{{ directive: {directive}; inputs: {inputs}; outputs: {outputs}; }}")
+        })
+        .collect();
+
+    format!("[{}]", entries.join(", "))
+}
+
+/// Extract a directive name from an `OutputExpression`.
+///
+/// Handles:
+/// - `ReadVar`: simple variable name (e.g. `SomeDirective`)
+/// - `ReadProp`: namespace-qualified reference (e.g. `i1.SomeDirective`)
+/// - `External`: external module reference, using the export name
+fn extract_directive_name_from_expr(expr: &crate::output::ast::OutputExpression) -> String {
+    match expr {
+        crate::output::ast::OutputExpression::ReadVar(read_var) => {
+            read_var.name.as_str().to_string()
+        }
+        crate::output::ast::OutputExpression::ReadProp(read_prop) => {
+            let receiver = extract_directive_name_from_expr(&read_prop.receiver);
+            format!("{}.{}", receiver, read_prop.name.as_str())
+        }
+        crate::output::ast::OutputExpression::External(external) => match &external.value.name {
+            Some(name) => name.as_str().to_string(),
+            None => panic!("ExternalExpr in host directive has no export name"),
+        },
+        other => {
+            panic!(
+                "Unexpected OutputExpression variant in host directive type: {:?}",
+                std::mem::discriminant(other)
+            )
+        }
+    }
+}
+
+/// Escape a string for use in a TypeScript `.d.ts` string literal type.
+fn escape_dts_string(s: &str) -> String {
+    s.replace('\\', "\\\\")
+        .replace('"', "\\\"")
+        .replace('\n', "\\n")
+        .replace('\r', "\\r")
+        .replace('\t', "\\t")
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_type_with_parameters_no_params() {
+        assert_eq!(type_with_parameters("MyComponent", 0), "MyComponent");
+    }
+
+    #[test]
+    fn test_type_with_parameters_with_params() {
+        assert_eq!(type_with_parameters("MyComponent", 2), "MyComponent<any, any>");
+    }
+
+    #[test]
+    fn test_escape_dts_string() {
+        assert_eq!(escape_dts_string("hello"), "hello");
+        assert_eq!(escape_dts_string(r#"he"llo"#), r#"he\"llo"#);
+        assert_eq!(escape_dts_string(r"he\llo"), r"he\\llo");
+        assert_eq!(escape_dts_string("line1\nline2"), "line1\\nline2");
+        assert_eq!(escape_dts_string("col1\tcol2"), "col1\\tcol2");
+        assert_eq!(escape_dts_string("a\r\nb"), "a\\r\\nb");
+    }
+
+    #[test]
+    fn test_generate_input_map_type_empty() {
+        let inputs: Vec<R3InputMetadata> = vec![];
+        assert_eq!(generate_input_map_type(&inputs), "{}");
+    }
+
+    #[test]
+    fn test_generate_output_map_type_empty() {
+        let outputs: Vec<(oxc_span::Atom, oxc_span::Atom)> = vec![];
+        assert_eq!(generate_output_map_type(&outputs), "{}");
+    }
+}
diff --git a/crates/oxc_angular_compiler/src/lib.rs b/crates/oxc_angular_compiler/src/lib.rs
index 3e58b3e14..2c28b0590 100644
--- a/crates/oxc_angular_compiler/src/lib.rs
+++ b/crates/oxc_angular_compiler/src/lib.rs
@@ -31,6 +31,7 @@ pub mod class_debug_info;
 pub mod class_metadata;
 pub mod component;
 pub mod directive;
+pub mod dts;
 pub mod factory;
 pub mod hmr;
 pub mod i18n;
@@ -135,6 +136,12 @@ pub use class_metadata::{
     compile_opaque_async_class_metadata,
 };
 
+// Re-export dts types
+pub use dts::{
+    DtsDeclaration, generate_component_dts, generate_directive_dts, generate_injectable_dts,
+    generate_ng_module_dts, generate_pipe_dts,
+};
+
 // Re-export linker types
 pub use linker::{LinkResult, link};
 
diff --git a/crates/oxc_angular_compiler/tests/integration_test.rs b/crates/oxc_angular_compiler/tests/integration_test.rs
index 16c93e0dd..0a2edf25f 100644
--- a/crates/oxc_angular_compiler/tests/integration_test.rs
+++ b/crates/oxc_angular_compiler/tests/integration_test.rs
@@ -6503,3 +6503,898 @@ fn test_sourcemap_no_angular_classes() {
         "Should return a source map even for files with no Angular classes when sourcemap: true"
     );
 }
+
+// =============================================================================
+// .d.ts Declaration Generation Tests (Issue #86)
+// =============================================================================
+
+#[test]
+fn test_dts_component_basic() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-hello',
+  standalone: true,
+  template: '<p>Hello</p>'
+})
+export class HelloComponent {}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "hello.component.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    // Should have exactly one dts declaration
+    assert_eq!(result.dts_declarations.len(), 1, "Should have one dts declaration");
+
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "HelloComponent");
+
+    // Should contain ɵfac declaration
+    assert!(
+        decl.members.contains("static ɵfac: i0.ɵɵFactoryDeclaration<HelloComponent, never>;"),
+        "Should contain ɵfac declaration. Got:\n{}",
+        decl.members
+    );
+
+    // Should contain ɵcmp declaration with correct selector
+    assert!(
+        decl.members
+            .contains("static ɵcmp: i0.ɵɵComponentDeclaration<HelloComponent, \"app-hello\""),
+        "Should contain ɵcmp declaration with selector. Got:\n{}",
+        decl.members
+    );
+
+    // Should include standalone: true
+    assert!(
+        decl.members.contains("true, never>;"),
+        "Should include standalone=true. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_component_with_inputs_outputs() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component, Input, Output, EventEmitter } from '@angular/core';
+
+@Component({
+  selector: 'app-user',
+  standalone: true,
+  template: '<p>{{name}}</p>'
+})
+export class UserComponent {
+  @Input() name: string = '';
+  @Input({ required: true, alias: 'userId' }) id!: number;
+  @Output() clicked = new EventEmitter<void>();
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "user.component.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "UserComponent");
+
+    // Should contain input map with proper metadata
+    assert!(
+        decl.members.contains(r#""name": { "alias": "name"; "required": false; }"#),
+        "Should contain name input metadata. Got:\n{}",
+        decl.members
+    );
+    assert!(
+        decl.members.contains(r#""id": { "alias": "userId"; "required": true; }"#),
+        "Should contain id input metadata with alias. Got:\n{}",
+        decl.members
+    );
+
+    // Should contain output map
+    assert!(
+        decl.members.contains(r#""clicked": "clicked""#),
+        "Should contain output metadata. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_component_non_standalone() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-legacy',
+  standalone: false,
+  template: '<p>Legacy</p>'
+})
+export class LegacyComponent {}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "legacy.component.ts", source, &options, None);
+    assert!(!result.has_errors());
+
+    let decl = &result.dts_declarations[0];
+    // Should include standalone: false
+    assert!(
+        decl.members.contains("false, never>;"),
+        "Should include standalone=false. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_component_with_export_as() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-tooltip',
+  standalone: true,
+  exportAs: 'tooltip',
+  template: '<ng-content></ng-content>'
+})
+export class TooltipComponent {}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "tooltip.component.ts", source, &options, None);
+    assert!(!result.has_errors());
+
+    let decl = &result.dts_declarations[0];
+    assert!(
+        decl.members.contains(r#"["tooltip"]"#),
+        "Should contain exportAs array. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_directive() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Directive, Input, Output, EventEmitter } from '@angular/core';
+
+@Directive({
+  selector: '[appHighlight]',
+  standalone: true,
+  exportAs: 'highlight'
+})
+export class HighlightDirective {
+  @Input() color: string = 'yellow';
+  @Output() highlighted = new EventEmitter<boolean>();
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result =
+        transform_angular_file(&allocator, "highlight.directive.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "HighlightDirective");
+
+    // Should have ɵfac
+    assert!(
+        decl.members.contains("static ɵfac: i0.ɵɵFactoryDeclaration<HighlightDirective, never>;"),
+        "Should contain ɵfac. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵdir (not ɵcmp)
+    assert!(
+        decl.members.contains(
+            "static ɵdir: i0.ɵɵDirectiveDeclaration<HighlightDirective, \"[appHighlight]\""
+        ),
+        "Should contain ɵdir with selector. Got:\n{}",
+        decl.members
+    );
+
+    // Should contain exportAs
+    assert!(
+        decl.members.contains(r#"["highlight"]"#),
+        "Should contain exportAs. Got:\n{}",
+        decl.members
+    );
+
+    // Should contain input metadata
+    assert!(
+        decl.members.contains(r#""color": { "alias": "color"; "required": false; }"#),
+        "Should contain input metadata. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_pipe() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  name: 'capitalize',
+  standalone: true
+})
+export class CapitalizePipe implements PipeTransform {
+  transform(value: string): string {
+    return value.charAt(0).toUpperCase() + value.slice(1);
+  }
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "capitalize.pipe.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "CapitalizePipe");
+
+    // Should have ɵfac
+    assert!(
+        decl.members.contains("static ɵfac: i0.ɵɵFactoryDeclaration<CapitalizePipe, never>;"),
+        "Should contain ɵfac. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵpipe with correct name and standalone
+    assert!(
+        decl.members
+            .contains(r#"static ɵpipe: i0.ɵɵPipeDeclaration<CapitalizePipe, "capitalize", true>;"#),
+        "Should contain ɵpipe declaration. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_pipe_no_name() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({
+  standalone: true
+})
+export class MyPipe implements PipeTransform {
+  transform(value: string): string {
+    return value;
+  }
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "my.pipe.ts", source, &options, None);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "MyPipe");
+
+    // When pipe name is None, should emit `null` (not `""`)
+    assert!(
+        decl.members.contains("static ɵpipe: i0.ɵɵPipeDeclaration<MyPipe, null, true>;"),
+        "Should use null for missing pipe name. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_ng_module() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { NgModule } from '@angular/core';
+import { CommonModule } from '@angular/common';
+
+@NgModule({
+  declarations: [MyComponent],
+  imports: [CommonModule],
+  exports: [MyComponent]
+})
+export class MyModule {}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "my.module.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "MyModule");
+
+    // Should have ɵfac
+    assert!(
+        decl.members.contains("static ɵfac: i0.ɵɵFactoryDeclaration<MyModule, never>;"),
+        "Should contain ɵfac. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵmod with declarations, imports, exports
+    assert!(
+        decl.members.contains("static ɵmod: i0.ɵɵNgModuleDeclaration<MyModule,"),
+        "Should contain ɵmod. Got:\n{}",
+        decl.members
+    );
+    assert!(
+        decl.members.contains("typeof MyComponent"),
+        "Should reference MyComponent with typeof. Got:\n{}",
+        decl.members
+    );
+    assert!(
+        decl.members.contains("typeof CommonModule"),
+        "Should reference CommonModule with typeof. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵinj
+    assert!(
+        decl.members.contains("static ɵinj: i0.ɵɵInjectorDeclaration<MyModule>;"),
+        "Should contain ɵinj. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_injectable() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class DataService {
+  getData() { return []; }
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "data.service.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "DataService");
+
+    // Should have ɵfac
+    assert!(
+        decl.members.contains("static ɵfac: i0.ɵɵFactoryDeclaration<DataService, never>;"),
+        "Should contain ɵfac. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵprov
+    assert!(
+        decl.members.contains("static ɵprov: i0.ɵɵInjectableDeclaration<DataService>;"),
+        "Should contain ɵprov. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_generic_injectable() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Injectable } from '@angular/core';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class GenericService<T, U> {
+  getData(): T | U { return null!; }
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "generic.service.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "GenericService");
+
+    // Should have ɵfac with type parameters filled as `any`
+    assert!(
+        decl.members
+            .contains("static ɵfac: i0.ɵɵFactoryDeclaration<GenericService<any, any>, never>;"),
+        "Should contain ɵfac with generic params. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵprov with type parameters filled as `any`
+    assert!(
+        decl.members
+            .contains("static ɵprov: i0.ɵɵInjectableDeclaration<GenericService<any, any>>;"),
+        "Should contain ɵprov with generic params. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_generic_pipe() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Pipe, PipeTransform } from '@angular/core';
+
+@Pipe({ name: 'genericPipe', standalone: true })
+export class GenericPipe<T> implements PipeTransform {
+  transform(value: T): T { return value; }
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "generic.pipe.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "GenericPipe");
+
+    // Should have ɵfac with type parameter filled as `any`
+    assert!(
+        decl.members.contains("static ɵfac: i0.ɵɵFactoryDeclaration<GenericPipe<any>, never>;"),
+        "Should contain ɵfac with generic param. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵpipe with type parameter filled as `any`
+    assert!(
+        decl.members.contains("i0.ɵɵPipeDeclaration<GenericPipe<any>,"),
+        "Should contain ɵpipe with generic param. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_generic_directive() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Directive, Input } from '@angular/core';
+
+@Directive({
+  selector: '[appGeneric]',
+  standalone: true
+})
+export class GenericDirective<T, U> {
+  @Input() value!: T;
+  @Input() extra!: U;
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "generic.directive.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "GenericDirective");
+
+    // Should have ɵfac with type parameters filled as `any`
+    assert!(
+        decl.members
+            .contains("static ɵfac: i0.ɵɵFactoryDeclaration<GenericDirective<any, any>, never>;"),
+        "Should contain ɵfac with generic params. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵdir with type parameters filled as `any`
+    assert!(
+        decl.members.contains("i0.ɵɵDirectiveDeclaration<GenericDirective<any, any>,"),
+        "Should contain ɵdir with generic params. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_generic_ng_module() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { NgModule } from '@angular/core';
+
+@NgModule({})
+export class GenericModule<T> {}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "generic.module.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "GenericModule");
+
+    // Should have ɵfac with type parameter filled as `any`
+    assert!(
+        decl.members.contains("static ɵfac: i0.ɵɵFactoryDeclaration<GenericModule<any>, never>;"),
+        "Should contain ɵfac with generic param. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵmod with type parameter filled as `any`
+    assert!(
+        decl.members.contains("i0.ɵɵNgModuleDeclaration<GenericModule<any>,"),
+        "Should contain ɵmod with generic param. Got:\n{}",
+        decl.members
+    );
+
+    // Should have ɵinj with type parameter filled as `any`
+    assert!(
+        decl.members.contains("static ɵinj: i0.ɵɵInjectorDeclaration<GenericModule<any>>;"),
+        "Should contain ɵinj with generic param. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_multiple_classes_in_file() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component, Injectable, Pipe, PipeTransform } from '@angular/core';
+
+@Injectable({ providedIn: 'root' })
+export class MyService {}
+
+@Pipe({ name: 'myPipe', standalone: true })
+export class MyPipe implements PipeTransform {
+  transform(v: any) { return v; }
+}
+
+@Component({
+  selector: 'app-multi',
+  standalone: true,
+  template: '<p>{{value | myPipe}}</p>'
+})
+export class MultiComponent {}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "multi.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    // Should have declarations for all 3 classes
+    assert_eq!(
+        result.dts_declarations.len(),
+        3,
+        "Should have 3 dts declarations. Got: {:?}",
+        result.dts_declarations.iter().map(|d| &d.class_name).collect::<Vec<_>>()
+    );
+
+    let class_names: Vec<&str> =
+        result.dts_declarations.iter().map(|d| d.class_name.as_str()).collect();
+    assert!(class_names.contains(&"MyService"), "Should have MyService");
+    assert!(class_names.contains(&"MyPipe"), "Should have MyPipe");
+    assert!(class_names.contains(&"MultiComponent"), "Should have MultiComponent");
+}
+
+#[test]
+fn test_dts_no_declarations_for_plain_class() {
+    let allocator = Allocator::default();
+    let source = r#"
+export class PlainClass {
+  doStuff() { return 42; }
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "plain.ts", source, &options, None);
+
+    // Should have no dts declarations for plain classes
+    assert!(
+        result.dts_declarations.is_empty(),
+        "Should have no dts declarations for plain classes"
+    );
+}
+
+#[test]
+fn test_dts_component_with_signal_input() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component, input } from '@angular/core';
+
+@Component({
+  selector: 'app-signal',
+  standalone: true,
+  template: '<p>{{name()}}</p>'
+})
+export class SignalComponent {
+  name = input<string>('default');
+  required = input.required<number>();
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "signal.component.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    assert_eq!(result.dts_declarations.len(), 1);
+    let decl = &result.dts_declarations[0];
+
+    // Signal inputs should have isSignal: true in the input map
+    assert!(
+        decl.members.contains(r#""isSignal": true"#),
+        "Signal inputs should have isSignal: true. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_component_ctor_deps_with_attribute() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component, Attribute } from '@angular/core';
+import { MyService } from './my.service';
+
+@Component({
+  selector: 'app-test',
+  standalone: true,
+  template: '<p>Test</p>'
+})
+export class TestComponent {
+  constructor(
+    private svc: MyService,
+    @Attribute('title') title: string
+  ) {}
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "test.component.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    let decl = &result.dts_declarations[0];
+    // When any dep has @Attribute, should emit a tuple with object types
+    // First dep has no flags -> null, second has attribute -> {attribute: "title"}
+    assert!(
+        decl.members.contains("[null, { attribute: \"title\" }]"),
+        "Should emit tuple with attribute object type. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_component_ctor_deps_with_optional() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component, Optional } from '@angular/core';
+import { MyService } from './my.service';
+
+@Component({
+  selector: 'app-test',
+  standalone: true,
+  template: '<p>Test</p>'
+})
+export class TestComponent {
+  constructor(
+    @Optional() private svc: MyService
+  ) {}
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "test.component.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    let decl = &result.dts_declarations[0];
+    // @Optional without @Attribute -> dep has optional flag but no attribute
+    // Since optional is a flag, it should appear in the object type
+    assert!(
+        decl.members.contains("[{ optional: true }]"),
+        "Should emit tuple with optional object type. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_component_ctor_deps_no_flags() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component } from '@angular/core';
+import { MyService } from './my.service';
+
+@Component({
+  selector: 'app-test',
+  standalone: true,
+  template: '<p>Test</p>'
+})
+export class TestComponent {
+  constructor(private svc: MyService) {}
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "test.component.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    let decl = &result.dts_declarations[0];
+    // No special flags -> never
+    assert!(
+        decl.members.contains("ɵɵFactoryDeclaration<TestComponent, never>"),
+        "Should emit never for deps with no flags. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_directive_ctor_deps_with_optional_and_host() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Directive, Optional, Host } from '@angular/core';
+import { MyService } from './my.service';
+import { OtherService } from './other.service';
+
+@Directive({
+  selector: '[appTest]',
+  standalone: true,
+})
+export class TestDirective {
+  constructor(
+    @Optional() @Host() private svc: MyService,
+    private other: OtherService
+  ) {}
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "test.directive.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    let decl = &result.dts_declarations[0];
+    // First dep has optional + host, second has no flags -> null
+    assert!(
+        decl.members.contains("[{ optional: true, host: true }, null]"),
+        "Should emit tuple with optional+host object type and null. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_component_with_ng_content_selectors() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component } from '@angular/core';
+
+@Component({
+  selector: 'app-layout',
+  standalone: true,
+  template: `
+    <ng-content select="header"></ng-content>
+    <ng-content></ng-content>
+    <ng-content select=".footer"></ng-content>
+  `
+})
+export class LayoutComponent {}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "layout.component.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    let decl = &result.dts_declarations[0];
+
+    // Should contain ng-content selectors as a tuple type in the ɵcmp declaration
+    assert!(
+        decl.members.contains(r#"["header", "*", ".footer"]"#),
+        "Should contain ng-content selectors tuple. Got:\n{}",
+        decl.members
+    );
+
+    // Verify the full ɵcmp declaration structure has selectors in the correct position
+    // (after QueryFields=never, before IsStandalone=true)
+    assert!(
+        decl.members.contains(r#"never, ["header", "*", ".footer"], true"#),
+        "NgContentSelectors should be in the correct position between QueryFields and IsStandalone. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_component_with_input_transform() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component, Input, booleanAttribute } from '@angular/core';
+
+@Component({
+  selector: 'app-test',
+  standalone: true,
+  template: '<p>test</p>'
+})
+export class TestComponent {
+  @Input({transform: booleanAttribute}) disabled: boolean = false;
+  @Input() name: string = '';
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "test.component.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "TestComponent");
+
+    // Input with transform should get ngAcceptInputType_* field
+    assert!(
+        decl.members.contains("static ngAcceptInputType_disabled: unknown;"),
+        "Should contain ngAcceptInputType_disabled for transformed input. Got:\n{}",
+        decl.members
+    );
+
+    // Input without transform should NOT get ngAcceptInputType_* field
+    assert!(
+        !decl.members.contains("ngAcceptInputType_name"),
+        "Should NOT contain ngAcceptInputType_name for non-transformed input. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_directive_with_input_transform() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Directive, Input, booleanAttribute } from '@angular/core';
+
+@Directive({
+  selector: '[appTest]',
+  standalone: true,
+})
+export class TestDirective {
+  @Input({transform: booleanAttribute}) disabled: boolean = false;
+  @Input() name: string = '';
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "test.directive.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "TestDirective");
+
+    // Input with transform should get ngAcceptInputType_* field
+    assert!(
+        decl.members.contains("static ngAcceptInputType_disabled: unknown;"),
+        "Should contain ngAcceptInputType_disabled for transformed input. Got:\n{}",
+        decl.members
+    );
+
+    // Input without transform should NOT get ngAcceptInputType_* field
+    assert!(
+        !decl.members.contains("ngAcceptInputType_name"),
+        "Should NOT contain ngAcceptInputType_name for non-transformed input. Got:\n{}",
+        decl.members
+    );
+}
+
+#[test]
+fn test_dts_signal_input_with_transform_no_accept_type() {
+    let allocator = Allocator::default();
+    let source = r#"
+import { Component, input, booleanAttribute } from '@angular/core';
+
+@Component({
+  selector: 'app-test',
+  standalone: true,
+  template: '<p>test</p>'
+})
+export class TestComponent {
+  disabled = input(false, {transform: booleanAttribute});
+}
+"#;
+
+    let options = ComponentTransformOptions::default();
+    let result = transform_angular_file(&allocator, "test.component.ts", source, &options, None);
+    assert!(!result.has_errors(), "Should compile without errors: {:?}", result.diagnostics);
+
+    let decl = &result.dts_declarations[0];
+    assert_eq!(decl.class_name, "TestComponent");
+
+    // Signal inputs should NOT get ngAcceptInputType_* fields
+    assert!(
+        !decl.members.contains("ngAcceptInputType_"),
+        "Signal inputs should NOT get ngAcceptInputType_* fields. Got:\n{}",
+        decl.members
+    );
+}
diff --git a/napi/angular-compiler/index.d.ts b/napi/angular-compiler/index.d.ts
index d00654182..0d1d2a6cb 100644
--- a/napi/angular-compiler/index.d.ts
+++ b/napi/angular-compiler/index.d.ts
@@ -185,6 +185,22 @@ export interface DependencyMetadata {
   skipSelf?: boolean
 }
 
+/**
+ * A `.d.ts` type declaration for an Angular class.
+ *
+ * Contains the class name and the static member declarations
+ * that should be injected into the corresponding `.d.ts` class body.
+ */
+export interface DtsDeclaration {
+  /** The name of the class. */
+  className: string
+  /**
+   * The static member declarations to add to the class body in `.d.ts`.
+   * Newline-separated `static` property declarations.
+   */
+  members: string
+}
+
 /**
  * Encapsulate CSS styles for a component using attribute selectors.
  *
@@ -839,6 +855,19 @@ export interface TransformResult {
   errors: Array<OxcError>
   /** Compilation warnings. */
   warnings: Array<OxcError>
+  /**
+   * `.d.ts` type declarations for Angular classes.
+   *
+   * Each entry contains the class name and the static member declarations
+   * that should be injected into the corresponding `.d.ts` class body.
+   * This enables library builds to include proper Ivy type declarations
+   * for template type-checking by consumers.
+   *
+   * The declarations use `i0` as the namespace alias for `@angular/core`.
+   * Consumers must ensure their `.d.ts` files include:
+   * `import * as i0 from "@angular/core";`
+   */
+  dtsDeclarations: Array<DtsDeclaration>
 }
 export interface Comment {
   type: 'Line' | 'Block'
diff --git a/napi/angular-compiler/src/lib.rs b/napi/angular-compiler/src/lib.rs
index a51a7a049..818984c9c 100644
--- a/napi/angular-compiler/src/lib.rs
+++ b/napi/angular-compiler/src/lib.rs
@@ -272,6 +272,20 @@ pub struct TemplateCompileResult {
     pub errors: Vec<OxcError>,
 }
 
+/// A `.d.ts` type declaration for an Angular class.
+///
+/// Contains the class name and the static member declarations
+/// that should be injected into the corresponding `.d.ts` class body.
+#[derive(Default)]
+#[napi(object)]
+pub struct DtsDeclaration {
+    /// The name of the class.
+    pub class_name: String,
+    /// The static member declarations to add to the class body in `.d.ts`.
+    /// Newline-separated `static` property declarations.
+    pub members: String,
+}
+
 /// Result of transforming an Angular file.
 #[derive(Default)]
 #[napi(object)]
@@ -298,6 +312,18 @@ pub struct TransformResult {
 
     /// Compilation warnings.
     pub warnings: Vec<OxcError>,
+
+    /// `.d.ts` type declarations for Angular classes.
+    ///
+    /// Each entry contains the class name and the static member declarations
+    /// that should be injected into the corresponding `.d.ts` class body.
+    /// This enables library builds to include proper Ivy type declarations
+    /// for template type-checking by consumers.
+    ///
+    /// The declarations use `i0` as the namespace alias for `@angular/core`.
+    /// Consumers must ensure their `.d.ts` files include:
+    /// `import * as i0 from "@angular/core";`
+    pub dts_declarations: Vec<DtsDeclaration>,
 }
 
 /// Compile an Angular template to JavaScript.
@@ -1042,6 +1068,11 @@ impl Task for TransformAngularFileTask {
             style_updates: result.style_updates,
             errors,
             warnings: vec![],
+            dts_declarations: result
+                .dts_declarations
+                .into_iter()
+                .map(|d| DtsDeclaration { class_name: d.class_name, members: d.members })
+                .collect(),
         })
     }