diff --git a/.github/workflows/pr-tests.yml b/.github/workflows/pr-tests.yml
index 6fa06bf..0abc2ae 100644
--- a/.github/workflows/pr-tests.yml
+++ b/.github/workflows/pr-tests.yml
@@ -27,6 +27,7 @@ concurrency:
 jobs:
   test:
     runs-on: windows-latest
+    timeout-minutes: 30  # Job-level timeout
     
     steps:
       - name: Checkout code
@@ -84,6 +85,7 @@ jobs:
       - name: Publish Test Results
         uses: EnricoMi/publish-unit-test-result-action/windows@v2
         if: always()
+        timeout-minutes: 5  # Step-level timeout
         with:
           files: |
             TestResults/**/*.trx
@@ -141,6 +143,7 @@ jobs:
 
   code-quality:
     runs-on: windows-latest
+    timeout-minutes: 20  # Job-level timeout
     
     steps:
       - name: Checkout code
@@ -181,6 +184,7 @@ jobs:
     runs-on: ubuntu-latest
     needs: [test, code-quality]
     if: always()
+    timeout-minutes: 5  # Job-level timeout
     
     steps:
       - name: Check Test Status
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index f0b455f..4a9797a 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -39,32 +39,30 @@ jobs:
           fetch-depth: 0
           fetch-tags: true
       
-      - name: Setup MSBuild
-        uses: microsoft/setup-msbuild@v2
-      
-      - name: Setup NuGet
-        uses: NuGet/setup-nuget@v2
-      
-      # Cache NuGet packages
-      - name: Cache NuGet packages
-        uses: actions/cache@v4
-        with:
-          path: |
-            ~/.nuget/packages
-            ${{ github.workspace }}/.nuget/packages
-          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json', '**/*.csproj') }}
-          restore-keys: |
-            ${{ runner.os }}-nuget-
-      
-      - name: Restore NuGet packages
-        run: nuget restore InterfaceExtractor.Extension/InterfaceExtractor.Extension.csproj
-      
       - name: Determine version bump type
         id: version-bump
         shell: bash
         run: |
-          # Get the last tag
-          LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+          BRANCH="${{ github.ref_name }}"
+          
+          # Check if this is a merge from dev to main
+          if [ "$BRANCH" == "main" ]; then
+            MERGE_MESSAGE=$(git log -1 --pretty=%B)
+            
+            if echo "$MERGE_MESSAGE" | grep -qiE "Merge pull request.*(from|dev)"; then
+              echo "🔀 Detected dev → main merge, will promote dev version to production"
+              echo "BUMP_TYPE=promotion" >> $GITHUB_OUTPUT
+              echo "CONVENTIONAL_COMMIT_FOUND=true" >> $GITHUB_OUTPUT
+              exit 0
+            fi
+            
+            # For main branch, check against last production tag
+            LAST_TAG=$(git tag -l "v*" --sort=-version:refname | grep -v "-" | head -1 || echo "v0.0.0")
+          else
+            # For dev branch, check against last tag (any type)
+            LAST_TAG=$(git describe --tags --abbrev=0 2>/dev/null || echo "v0.0.0")
+          fi
+          
           echo "Last tag: $LAST_TAG"
           
           # Get commits since last tag
@@ -73,32 +71,70 @@ jobs:
           echo "$COMMITS"
           
           # Determine bump type based on conventional commits
-          BUMP_TYPE="patch"
+          BUMP_TYPE="none"
+          CONVENTIONAL_COMMIT_FOUND="false"
           
           # Check for breaking changes (major version)
           if echo "$COMMITS" | grep -qiE "^(BREAKING CHANGE|.*!:)"; then
             BUMP_TYPE="major"
+            CONVENTIONAL_COMMIT_FOUND="true"
             echo "🚨 Breaking change detected → MAJOR version bump"
           # Check for features (minor version)
           elif echo "$COMMITS" | grep -qiE "^feat(\(.*\))?:"; then
             BUMP_TYPE="minor"
+            CONVENTIONAL_COMMIT_FOUND="true"
             echo "✨ New feature detected → MINOR version bump"
           # Check for fixes (patch version)
           elif echo "$COMMITS" | grep -qiE "^fix(\(.*\))?:"; then
             BUMP_TYPE="patch"
+            CONVENTIONAL_COMMIT_FOUND="true"
             echo "🐛 Bug fix detected → PATCH version bump"
           # Check for other conventional commit types
           elif echo "$COMMITS" | grep -qiE "^(chore|docs|style|refactor|perf|test|build|ci)(\(.*\))?:"; then
             BUMP_TYPE="patch"
+            CONVENTIONAL_COMMIT_FOUND="true"
             echo "🔧 Maintenance commit detected → PATCH version bump"
           else
-            BUMP_TYPE="patch"
-            echo "📝 No conventional commit detected → Default PATCH version bump"
+            BUMP_TYPE="none"
+            CONVENTIONAL_COMMIT_FOUND="false"
+            echo "⏭️ No conventional commit detected → Skipping build"
+            echo ""
+            echo "ℹ️ Use conventional commit format to trigger a release:"
+            echo "  • feat: for new features (minor version bump)"
+            echo "  • fix: for bug fixes (patch version bump)"
+            echo "  • chore/docs/style/refactor/perf/test: for maintenance (patch version bump)"
+            echo "  • BREAKING CHANGE or !: for breaking changes (major version bump)"
           fi
           
           echo "BUMP_TYPE=$BUMP_TYPE" >> $GITHUB_OUTPUT
+          echo "CONVENTIONAL_COMMIT_FOUND=$CONVENTIONAL_COMMIT_FOUND" >> $GITHUB_OUTPUT
+      
+      - name: Setup MSBuild
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
+        uses: microsoft/setup-msbuild@v2
+      
+      - name: Setup NuGet
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
+        uses: NuGet/setup-nuget@v2
+      
+      # Cache NuGet packages
+      - name: Cache NuGet packages
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.nuget/packages
+            ${{ github.workspace }}/.nuget/packages
+          key: ${{ runner.os }}-nuget-${{ hashFiles('**/packages.lock.json', '**/*.csproj') }}
+          restore-keys: |
+            ${{ runner.os }}-nuget-
+      
+      - name: Restore NuGet packages
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
+        run: nuget restore InterfaceExtractor.Extension/InterfaceExtractor.Extension.csproj
       
       - name: Auto-increment version
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
         id: version
         shell: pwsh
         run: |
@@ -125,80 +161,57 @@ jobs:
           $minor = [int]$versionParts[1]
           $patch = [int]$versionParts[2]
           
-          # Determine new version based on bump type
-          if ($bumpType -eq "major") {
-            $major++
-            $minor = 0
-            $patch = 0
-          }
-          elseif ($bumpType -eq "minor") {
-            $minor++
-            $patch = 0
+          # Handle promotion vs normal bump
+          if ($bumpType -eq "promotion") {
+            # Promotion: keep current version, just remove -dev suffix for display
+            Write-Host "🔀 Promoting dev version to production"
+            $baseVersion = "$major.$minor.$patch"
+            $newVersion = "$baseVersion.0"
+            $displayVersion = $baseVersion
+            $isPrerelease = "false"
+            $tagName = "v$displayVersion"
+            $releaseName = "v$displayVersion Release"
+            $releaseType = "production"
+            Write-Host "📦 Production version: $displayVersion (promoted from dev)"
           }
           else {
-            $patch++
-          }
-          
-          $baseVersion = "$major.$minor.$patch"
-          
-          # Determine prerelease type based on branch
-          if ($branchName -like "*testing*") {
-            # Testing branches: find the next testing prerelease number
-            $lastTestingTag = git tag -l "v$baseVersion-testing.*" --sort=-version:refname | Select-Object -First 1
-            
-            if ([string]::IsNullOrEmpty($lastTestingTag)) {
-              $prereleaseNum = 0
+            # Normal bump: increment version based on conventional commit type
+            if ($bumpType -eq "major") {
+              $major++
+              $minor = 0
+              $patch = 0
             }
-            elseif ($lastTestingTag -match 'testing\.(\d+)') {
-              $prereleaseNum = [int]$matches[1] + 1
+            elseif ($bumpType -eq "minor") {
+              $minor++
+              $patch = 0
             }
-            else {
-              Write-Host "⚠️ Warning: Could not parse testing tag '$lastTestingTag', starting from 0"
-              $prereleaseNum = 0
+            elseif ($bumpType -eq "patch") {
+              $patch++
             }
             
-            $prereleaseNum = $prereleaseNum.ToString("00")
-            $newVersion = "$baseVersion.$prereleaseNum"
-            $displayVersion = "$baseVersion-testing.$prereleaseNum"
-            $isPrerelease = "true"
-            $tagName = "v$displayVersion"
-            $releaseName = "v$displayVersion 🧪 Testing Release"
-            $releaseType = "testing"
-            Write-Host "🧪 Testing version: $displayVersion"
-          }
-          elseif ($branchName -eq "dev") {
-            # Dev branch: find the next dev prerelease number
-            $lastDevTag = git tag -l "v$baseVersion-dev.*" --sort=-version:refname | Select-Object -First 1
+            $baseVersion = "$major.$minor.$patch"
             
-            if ([string]::IsNullOrEmpty($lastDevTag)) {
-              $prereleaseNum = 0
-            }
-            elseif ($lastDevTag -match 'dev\.(\d+)') {
-              $prereleaseNum = [int]$matches[1] + 1
+            # Determine release type based on branch
+            if ($branchName -eq "dev") {
+              # Dev branch: add -dev suffix
+              $newVersion = "$baseVersion.0"
+              $displayVersion = "$baseVersion-dev"
+              $isPrerelease = "true"
+              $tagName = "v$displayVersion"
+              $releaseName = "v$displayVersion 🔧 Dev Release"
+              $releaseType = "dev"
+              Write-Host "🔧 Dev version: $displayVersion ($bumpType bump)"
             }
             else {
-              Write-Host "⚠️ Warning: Could not parse dev tag '$lastDevTag', starting from 0"
-              $prereleaseNum = 0
+              # Main branch: production release
+              $newVersion = "$baseVersion.0"
+              $displayVersion = $baseVersion
+              $isPrerelease = "false"
+              $tagName = "v$displayVersion"
+              $releaseName = "v$displayVersion Release"
+              $releaseType = "production"
+              Write-Host "📦 Production version: $displayVersion ($bumpType bump)"
             }
-            
-            $prereleaseNum = $prereleaseNum.ToString("00")
-            $newVersion = "$baseVersion.$prereleaseNum"
-            $displayVersion = "$baseVersion-dev.$prereleaseNum"
-            $isPrerelease = "true"
-            $tagName = "v$displayVersion"
-            $releaseName = "v$displayVersion 🔧 Dev Release"
-            $releaseType = "dev"
-            Write-Host "🔧 Dev version: $displayVersion"
-          }
-          else {
-            # Main branch: production release
-            $newVersion = "$baseVersion.0"
-            $displayVersion = $baseVersion
-            $isPrerelease = "false"
-            $tagName = "v$displayVersion"
-            $releaseName = "v$displayVersion Release"
-            $releaseType = "production"
-            Write-Host "📦 Production version: $displayVersion ($bumpType bump)"
           }
           
           Write-Host "New version will be: $newVersion (display: $displayVersion)"
@@ -225,11 +238,31 @@ jobs:
           "IS_PRERELEASE=$isPrerelease" | Out-File -FilePath $env:GITHUB_OUTPUT -Append
           "RELEASE_NAME=$releaseName" | Out-File -FilePath $env:GITHUB_OUTPUT -Append
           "RELEASE_TYPE=$releaseType" | Out-File -FilePath $env:GITHUB_OUTPUT -Append
-
+      
+      - name: Commit and push version bump
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
+        shell: bash
+        run: |
+          git config user.name "github-actions[bot]"
+          git config user.email "github-actions[bot]@users.noreply.github.com"
+          
+          # Check if there are changes to commit
+          if git diff --quiet InterfaceExtractor.Extension/source.extension.vsixmanifest; then
+            echo "ℹ️ No version changes to commit (version already up to date)"
+          else
+            echo "📝 Committing version bump to ${{ steps.version.outputs.VERSION }}"
+            git add InterfaceExtractor.Extension/source.extension.vsixmanifest
+            git commit -m "chore: bump version to ${{ steps.version.outputs.VERSION }} [skip ci]"
+            git push
+            echo "✅ Version bump committed and pushed"
+          fi
+      
       - name: Build Extension
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
         run: msbuild InterfaceExtractor.Extension/InterfaceExtractor.Extension.csproj /p:Configuration=Release /p:DeployExtension=false /p:ZipPackageCompressionLevel=normal /v:minimal /m
       
       - name: Locate VSIX file
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
         id: locate-vsix
         shell: bash
         run: |
@@ -251,6 +284,7 @@ jobs:
           echo "VSIX_NAME=$NEW_VSIX_NAME" >> $GITHUB_OUTPUT
       
       - name: Create and push git tag
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
         shell: bash
         run: |
           git config user.name "github-actions[bot]"
@@ -259,59 +293,157 @@ jobs:
           git push origin "${{ steps.version.outputs.TAG_NAME }}"
       
       - name: Generate release notes
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
         id: release-notes
-        shell: bash
+        shell: pwsh
         run: |
-          RELEASE_TYPE="${{ steps.version.outputs.RELEASE_TYPE }}"
+          $releaseType = "${{ steps.version.outputs.RELEASE_TYPE }}"
+          $displayVersion = "${{ steps.version.outputs.DISPLAY_VERSION }}"
+          $currentTag = "${{ steps.version.outputs.TAG_NAME }}"
+          $bumpType = "${{ steps.version-bump.outputs.BUMP_TYPE }}"
           
-          # Find the last tag of the same type
-          if [[ "$RELEASE_TYPE" == "testing" ]]; then
-            LAST_TAG=$(git tag -l "v*-testing.*" --sort=-version:refname | head -n 2 | tail -n 1)
-          elif [[ "$RELEASE_TYPE" == "dev" ]]; then
-            LAST_TAG=$(git tag -l "v*-dev.*" --sort=-version:refname | head -n 2 | tail -n 1)
-          else
-            LAST_TAG=$(git tag -l "v*" --sort=-version:refname | grep -v "-" | head -n 2 | tail -n 1)
-          fi
+          # Extract base version (e.g., "1.0.1" from "1.0.1-dev")
+          $baseVersion = $displayVersion -replace '-.*$', ''
           
-          # Get commits since last tag of this type with author information
-          if [ -z "$LAST_TAG" ]; then
-            COMMITS=$(git log --first-parent --pretty=format:"- %s by @%an (%h)" --reverse)
-            TAG_INFO="First $RELEASE_TYPE release"
-          else
-            COMMITS=$(git log --first-parent ${LAST_TAG}..HEAD --pretty=format:"- %s by @%an (%h)" --reverse)
-            TAG_INFO="Since $LAST_TAG"
-          fi
+          # Find the last tag of the same type (excluding current tag)
+          if ($releaseType -eq "dev") {
+            # Get last dev tag (excluding current)
+            $lastTag = git tag -l "v*-dev*" --sort=-version:refname | Where-Object { $_ -ne $currentTag } | Select-Object -First 1
+          }
+          else {
+            # Production releases: exclude current tag and any prerelease tags
+            $lastTag = git tag -l "v*" --sort=-version:refname | Where-Object { $_ -notmatch "-" -and $_ -ne $currentTag } | Select-Object -First 1
+          }
           
-          if [[ "${{ steps.version.outputs.IS_PRERELEASE }}" == "true" ]]; then
-            RELEASE_BODY="## Pre-release
-            
-          **Version:** v${{ steps.version.outputs.DISPLAY_VERSION }}
-          **Commit:** ${{ github.sha }}
+          Write-Host "Current tag: $currentTag"
+          Write-Host "Last tag: $lastTag"
           
-          **Changes ($TAG_INFO):**
-          $COMMITS
+          # Get commits using git log first (more reliable for commit ranges)
+          $commits = ""
+          if ([string]::IsNullOrEmpty($lastTag)) {
+            Write-Host "No previous tag found - using all commits"
+            $tagInfo = "First $releaseType release"
+            $gitCommits = git log --first-parent --pretty=format:"%H||%s" --reverse --grep="^chore: bump version" --invert-grep
+          }
+          else {
+            Write-Host "Getting commits between $lastTag and HEAD"
+            $tagInfo = "Since $lastTag"
+            $gitCommits = git log --first-parent "$lastTag..HEAD" --pretty=format:"%H||%s" --reverse --grep="^chore: bump version" --invert-grep
+          }
           
-          ## Installation
-          1. Download the \`.vsix\` file below
-          2. Double-click to install in Visual Studio
-          3. Or use: \`Extensions > Manage Extensions > Install from file\`"
-          else
-            RELEASE_BODY="## ${{ steps.version-bump.outputs.BUMP_TYPE == 'patch' && '🐛 Patch' || steps.version-bump.outputs.BUMP_TYPE == 'minor' && '✨ Minor' || '🚨 Major' }} Version Bump
+          # Try to enrich with GitHub usernames via API
+          $commitList = @()
+          try {
+            Write-Host "Enriching commits with GitHub usernames..."
+            
+            # Build SHA list for lookup
+            $shaMap = @{}
+            foreach ($line in $gitCommits) {
+              if ([string]::IsNullOrEmpty($line)) { continue }
+              
+              $parts = $line -split '\|\|'
+              if ($parts.Count -lt 2) { continue }
+              
+              $sha = $parts[0]
+              $message = $parts[1]
+              $shaMap[$sha] = $message
+            }
+            
+            if ($shaMap.Count -eq 0) {
+              throw "No commits to process"
+            }
+            
+            Write-Host "Found $($shaMap.Count) commits to enrich"
+            
+            # Fetch commit details from GitHub API (in batches if needed)
+            foreach ($sha in $shaMap.Keys) {
+              try {
+                $apiResponse = gh api "repos/${{ github.repository }}/commits/$sha" --jq '"\(.author.login // "unknown")"' 2>$null
+                
+                if ($LASTEXITCODE -eq 0 -and ![string]::IsNullOrEmpty($apiResponse)) {
+                  $author = $apiResponse.Trim()
+                  $message = $shaMap[$sha]
+                  $shortSha = $sha.Substring(0, 7)
+                  $commitList += "- $message by @$author ($shortSha)"
+                }
+                else {
+                  # Fallback to without username
+                  $message = $shaMap[$sha]
+                  $shortSha = $sha.Substring(0, 7)
+                  $commitList += "- $message ($shortSha)"
+                }
+              }
+              catch {
+                # Fallback to without username
+                $message = $shaMap[$sha]
+                $shortSha = $sha.Substring(0, 7)
+                $commitList += "- $message ($shortSha)"
+              }
+            }
+            
+            $commits = $commitList -join "`n"
+            Write-Host "✅ Successfully processed $($commitList.Count) commits"
+          }
+          catch {
+            Write-Host "⚠️ Could not enrich with GitHub usernames: $_"
+            Write-Host "Using plain git log format"
             
-          **Version:** v${{ steps.version.outputs.DISPLAY_VERSION }}
+            # Fallback to simple git log format
+            if ([string]::IsNullOrEmpty($lastTag)) {
+              $commits = git log --first-parent --pretty=format:"- %s (%h)" --reverse --grep="^chore: bump version" --invert-grep
+            }
+            else {
+              $commits = git log --first-parent "$lastTag..HEAD" --pretty=format:"- %s (%h)" --reverse --grep="^chore: bump version" --invert-grep
+            }
+          }
           
-          **Changes ($TAG_INFO):**
-          $COMMITS
+          # If no commits found, add a placeholder
+          if ([string]::IsNullOrEmpty($commits)) {
+            $commits = "- Initial release"
+          }
           
-          ## Installation
-          1. Download the \`.vsix\` file below
-          2. Double-click to install in Visual Studio
-          3. Or use: \`Extensions > Manage Extensions > Install from file\`"
-          fi
+          # Build installation instructions
+          $installation = "## Installation`n`n"
+          $installation += "1. Download the ``.vsix`` file below`n"
+          $installation += "2. Double-click to install in Visual Studio`n"
+          $installation += "3. Or use: ``Extensions > Manage Extensions > Install from file```n"
+          
+          # Build release body
+          $releaseBody = ""
+          
+          if ("${{ steps.version.outputs.IS_PRERELEASE }}" -eq "true") {
+            $releaseBody += "## Pre-release`n`n"
+            $releaseBody += "**Version:** v$displayVersion`n"
+            $releaseBody += "**Commit:** ${{ github.sha }}`n`n"
+            $releaseBody += "**Changes ($tagInfo):**`n"
+            $releaseBody += "$commits`n`n"
+            $releaseBody += $installation
+          }
+          else {
+            if ($bumpType -eq "promotion") {
+              $releaseBody += "## 🚀 Promoted from Dev`n`n"
+            }
+            else {
+              $emoji = switch ($bumpType) {
+                "major" { "🚨 Major" }
+                "minor" { "✨ Minor" }
+                default { "🐛 Patch" }
+              }
+              $releaseBody += "## $emoji Version Bump`n`n"
+            }
+            
+            $releaseBody += "**Version:** v$displayVersion`n`n"
+            $releaseBody += "**Changes ($tagInfo):**`n"
+            $releaseBody += "$commits`n`n"
+            $releaseBody += $installation
+          }
           
-          echo "$RELEASE_BODY" > release-notes.txt
+          $releaseBody | Out-File -FilePath release-notes.txt -Encoding utf8
+        env:
+          GH_TOKEN: ${{ github.token }}
       
       - name: Create GitHub Release with VSIX
+        if: steps.version-bump.outputs.CONVENTIONAL_COMMIT_FOUND == 'true'
         uses: softprops/action-gh-release@v2
         with:
           tag_name: ${{ steps.version.outputs.TAG_NAME }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
new file mode 100644
index 0000000..d4c24b2
--- /dev/null
+++ b/CHANGELOG.md
@@ -0,0 +1,148 @@
+# Changelog
+
+All notable changes to the Interface Extractor extension will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.2.0] - 2025-10-18
+
+### Added
+
+- **Interface Preview Dialog**: New preview window showing the complete generated interface before saving to disk
+  - View the full interface code with syntax highlighting
+  - See the exact file path where the interface will be saved
+  - Option to save or cancel the operation
+  - Can be disabled in options (Tools → Options → Interface Extractor → Behavior → Show Preview Before Saving)
+
+- **Multi-file Partial Class Support**: Automatically analyzes all partial class files across the project
+  - Scans project directory for other partial class definitions
+  - Combines members from all partial files into a single interface
+  - Avoids duplicate member signatures
+  - Controlled by option: "Analyze Partial Classes" (enabled by default)
+  - Logs which partial files were discovered and analyzed
+
+- **Record Type Support**: Extract interfaces from C# record types
+  - Works with both `record` and `record class` declarations
+  - Properly handles record properties and methods
+  - Auto-detects record types and includes them in analysis
+  - Updates records to implement interfaces (respects Auto Update Class option)
+  - Converts `init` accessors to `get` in interfaces (since `init` is not valid in interface declarations)
+
+- **Internal Member Support**: Optionally include internal members in interface extraction
+  - New option: "Include Internal Members" (disabled by default)
+  - Includes both explicitly internal and implicitly internal (no accessor) members
+  - Works for methods, properties, events, and indexers
+  - Useful for internal-facing interfaces
+
+- **Implementation Stub Generation**: Automatically create skeleton implementation classes
+  - New option: "Generate Implementation Stubs" (disabled by default)
+  - Generates class with NotImplementedException for methods
+  - Auto-implements properties with { get; set; }
+  - Configurable suffix for stub class names (default: "Implementation")
+  - Stubs placed in same Interfaces folder as the interface
+  - Preserves XML documentation from interface
+
+### Changed
+
+- Enhanced logging output with version number and detailed operation tracking
+- Improved type declaration handling to support both classes and records uniformly
+- Service method `AnalyzeClassesAsync` now accepts optional `projectDirectory` parameter for partial class scanning
+- Better accessibility detection with `IsAccessible()` helper method
+- Command execution now passes project directory to service for enhanced analysis
+
+### Fixed
+
+- Better handling of implicit internal accessibility for type declarations
+- Improved project item addition for generated stub files
+- More robust error handling during partial file analysis
+
+### Technical Details
+
+- Added `PreviewDialog.xaml` and `PreviewDialog.xaml.cs` for interface preview UI
+- Added `IsPartial` and `IsRecord` properties to `ExtractedClassInfo`
+- New `GenerateImplementationStub` method in `InterfaceExtractorService`
+- New `AnalyzePartialClassFiles` private method for multi-file scanning
+- Enhanced `ExtractPublicMembers` to handle both classes and records via `TypeDeclarationSyntax`
+- Options model extended with 5 new settings
+
+## [1.1.0] - 2025-10-18
+
+### Added
+
+- Comprehensive options page accessible through Tools → Options → Interface Extractor → General
+- Support for operator overloads (optional, disabled by default)
+- Custom file header templates with `{FileName}`, `{Date}`, `{Time}` placeholders
+- Member sorting options (sort alphabetically by type and name)
+- Member grouping options (group by Properties, Methods, Events, etc.)
+- Configurable member separator lines (0-3 blank lines between members)
+- "Add Using Directive" option for interface namespace imports
+- "Warn If No 'I' Prefix" option for interface naming validation
+- Automatic class update option (add interface to class declaration)
+
+### Changed
+
+- Moved configuration from hardcoded constants to user-editable options
+- Improved namespace handling to avoid self-referencing using statements
+- Enhanced interface generation with optional sorting and grouping
+- Better documentation preservation for all member types
+
+### Technical Details
+
+- Added `OptionsPage.cs` with `GeneralOptionsPage` and `ExtractorOptions` classes
+- Added `OptionsProvider` static class for options access throughout the extension
+- Enhanced `InterfaceExtractorService` constructor to accept options
+- Modified `GenerateInterface` to use template options
+- Added support for `OperatorDeclarationSyntax` and `ConversionOperatorDeclarationSyntax`
+
+## [1.0.0] - 2025-10-18
+
+### Added
+
+- Initial release of Interface Extractor extension
+- Right-click context menu integration in Solution Explorer for .cs files
+- Interactive member selection dialog with checkboxes
+- Automatic interface name suggestion with 'I' prefix
+- Support for extracting:
+  - Public methods (including generic methods with constraints)
+  - Public properties (with correct { get; set; } detection)
+  - Public events
+  - Public indexers
+- XML documentation comment preservation
+- Generic method constraint handling
+- Automatic interface file creation in "Interfaces" subfolder
+- Automatic namespace suffix (.Interfaces)
+- File overwrite protection with Yes/No/Yes to All/No to All options
+- Optional automatic class update to implement generated interface
+- Detailed logging to Visual Studio Output Window
+- Batch processing support for multiple files
+
+### Technical Details
+
+- Built on Visual Studio SDK 17.14
+- Uses Microsoft.CodeAnalysis.CSharp (Roslyn) for syntax analysis
+- Targets .NET Framework 4.8
+- WPF-based user interface dialogs
+- VSIX package format for distribution
+
+### Known Limitations
+
+- Only processes public, non-static members
+- Does not analyze nested classes
+- Partial classes: only processes current file
+- Operator overloads not included by default
+
+---
+
+## Version Number Scheme
+
+Interface Extractor follows [Semantic Versioning](https://semver.org/):
+
+- **MAJOR** version for incompatible API changes
+- **MINOR** version for new functionality in a backward compatible manner
+- **PATCH** version for backward compatible bug fixes
+
+Example: Version 1.2.0
+- **1** = Major version (initial release)
+- **2** = Minor version (new features: preview, partial classes, records, stubs, internal)
+- **0** = Patch version (no patches yet for this minor version)
\ No newline at end of file
diff --git a/InterfaceExtractor.Extension/Commands/ExtractInterfaceCommand.cs b/InterfaceExtractor.Extension/Commands/ExtractInterfaceCommand.cs
index 2c208b5..ec4e8ed 100644
--- a/InterfaceExtractor.Extension/Commands/ExtractInterfaceCommand.cs
+++ b/InterfaceExtractor.Extension/Commands/ExtractInterfaceCommand.cs
@@ -2,6 +2,7 @@
 using EnvDTE80;
 using Microsoft.VisualStudio.Shell;
 using Microsoft.VisualStudio.Shell.Interop;
+using InterfaceExtractor.Options;
 using System;
 using System.ComponentModel.Design;
 using System.IO;
@@ -18,6 +19,7 @@ internal sealed class ExtractInterfaceCommand
         private readonly AsyncPackage package;
         private readonly Services.InterfaceExtractorService extractorService;
         private readonly DTE2 dte;
+        private readonly ExtractorOptions options;
         private IVsOutputWindowPane outputPane;
 
         private ExtractInterfaceCommand(AsyncPackage package, OleMenuCommandService commandService, DTE2 dte)
@@ -26,7 +28,8 @@ private ExtractInterfaceCommand(AsyncPackage package, OleMenuCommandService comm
             this.dte = dte ?? throw new ArgumentNullException(nameof(dte));
             commandService = commandService ?? throw new ArgumentNullException(nameof(commandService));
 
-            extractorService = new Services.InterfaceExtractorService();
+            options = OptionsProvider.GetOptions(package);
+            extractorService = new Services.InterfaceExtractorService(options);
 
             var menuCommandID = new CommandID(CommandSet, CommandId);
             var menuItem = new OleMenuCommand(this.Execute, menuCommandID);
@@ -40,13 +43,11 @@ public static async Task InitializeAsync(AsyncPackage package)
         {
             await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(package.DisposalToken);
 
-            // Get services asynchronously
             var commandService = await package.GetServiceAsync(typeof(IMenuCommandService)) as OleMenuCommandService;
             var dte = await package.GetServiceAsync(typeof(DTE)) as DTE2;
 
             Instance = new ExtractInterfaceCommand(package, commandService, dte);
 
-            // Initialize output pane
             await Instance.InitializeOutputPaneAsync();
         }
 
@@ -73,7 +74,6 @@ private void OnBeforeQueryStatus(object sender, EventArgs e)
         {
             ThreadHelper.ThrowIfNotOnUIThread();
 
-            // Pattern matching (C# 7.3 compatible)
             if (!(sender is OleMenuCommand command)) return;
 
             command.Visible = false;
@@ -98,7 +98,6 @@ private void OnBeforeQueryStatus(object sender, EventArgs e)
 
         private void Execute(object sender, EventArgs e)
         {
-            // Use the package's JoinableTaskFactory for proper async execution
             this.package.JoinableTaskFactory.RunAsync(async () =>
             {
                 try
@@ -119,7 +118,12 @@ private async Task ExecuteAsync()
         {
             await ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync();
 
+            LogMessage("=== Interface Extractor v1.2.0 ===");
             LogMessage("Starting interface extraction...");
+            LogMessage($"Options: Folder={options.InterfacesFolderName}, Prefix={options.InterfacePrefix}");
+            LogMessage($"  AutoUpdate={options.AutoUpdateClass}, IncludeOperators={options.IncludeOperatorOverloads}");
+            LogMessage($"  ShowPreview={options.ShowPreviewBeforeSaving}, IncludeInternal={options.IncludeInternalMembers}");
+            LogMessage($"  AnalyzePartial={options.AnalyzePartialClasses}, GenerateStubs={options.GenerateImplementationStubs}");
 
             if (dte?.SelectedItems == null)
             {
@@ -136,9 +140,13 @@ private async Task ExecuteAsync()
                 .Select(item =>
                 {
                     ThreadHelper.ThrowIfNotOnUIThread();
-                    return item.ProjectItem.FileNames[1];
+                    return new
+                    {
+                        Path = item.ProjectItem.FileNames[1],
+                        item.ProjectItem
+                    };
                 })
-                .Where(path => Path.GetExtension(path).Equals(Constants.CSharpExtension, StringComparison.OrdinalIgnoreCase))
+                .Where(f => Path.GetExtension(f.Path).Equals(Constants.CSharpExtension, StringComparison.OrdinalIgnoreCase))
                 .ToList();
 
             if (!selectedFiles.Any())
@@ -153,37 +161,45 @@ private async Task ExecuteAsync()
             int failCount = 0;
             int skippedCount = 0;
 
-            // Track overwrite preference across all files
             OverwriteChoice overwriteChoice = OverwriteChoice.Ask;
 
-            foreach (var filePath in selectedFiles)
+            foreach (var file in selectedFiles)
             {
+                var filePath = file.Path;
                 LogMessage($"Analyzing: {Path.GetFileName(filePath)}");
 
                 try
                 {
-                    // Analyze the class(es)
-                    var classInfos = await extractorService.AnalyzeClassesAsync(filePath);
+                    // Get project directory for partial class analysis
+                    string projectDirectory = null;
+                    if (file.ProjectItem?.ContainingProject != null)
+                    {
+                        var projectPath = file.ProjectItem.ContainingProject.FullName;
+                        projectDirectory = Path.GetDirectoryName(projectPath);
+                    }
+
+                    var classInfos = await extractorService.AnalyzeClassesAsync(filePath, projectDirectory);
 
                     if (!classInfos.Any())
                     {
-                        LogMessage($"  No public classes with members found in {Path.GetFileName(filePath)}");
+                        LogMessage($"  No public classes/records with members found in {Path.GetFileName(filePath)}");
                         skippedCount++;
                         continue;
                     }
 
-                    // If multiple classes, let user choose or process all
                     foreach (var classInfo in classInfos)
                     {
-                        LogMessage($"  Found class: {classInfo.ClassName} with {classInfo.Members.Count} public member(s)");
+                        var typeKind = classInfo.IsRecord ? "record" : "class";
+                        var partialInfo = classInfo.IsPartial ? " (partial)" : "";
+
+                        LogMessage($"  Found {typeKind}: {classInfo.ClassName}{partialInfo} with {classInfo.Members.Count} member(s)");
 
                         if (!classInfo.Members.Any())
                         {
-                            LogMessage($"  No public members found in class {classInfo.ClassName}");
+                            LogMessage($"  No accessible members found in {typeKind} {classInfo.ClassName}");
                             continue;
                         }
 
-                        // Convert to selection items
                         var selectionItems = classInfo.Members.Select(m => new UI.MemberSelectionItem
                         {
                             DisplayText = m.Signature,
@@ -193,8 +209,7 @@ private async Task ExecuteAsync()
                             IsSelected = true
                         }).ToList();
 
-                        // Show dialog
-                        var dialog = new UI.ExtractInterfaceDialog(classInfo.ClassName, selectionItems);
+                        var dialog = new UI.ExtractInterfaceDialog(classInfo.ClassName, selectionItems, options);
                         var dialogResult = dialog.ShowDialog();
 
                         if (dialogResult != true)
@@ -204,7 +219,6 @@ private async Task ExecuteAsync()
                             continue;
                         }
 
-                        // Validate interface name
                         if (!IsValidInterfaceName(dialog.InterfaceName, out string validationError))
                         {
                             ShowMessage($"Invalid interface name: {validationError}");
@@ -212,7 +226,6 @@ private async Task ExecuteAsync()
                             continue;
                         }
 
-                        // Get selected members
                         var selectedMembers = classInfo.Members
                             .Where((m, i) => selectionItems[i].IsSelected)
                             .ToList();
@@ -226,19 +239,37 @@ private async Task ExecuteAsync()
 
                         LogMessage($"  Generating interface {dialog.InterfaceName} with {selectedMembers.Count} member(s)");
 
-                        // Generate interface code
-                        var interfaceCode = Services.InterfaceExtractorService.GenerateInterface(
+                        var interfaceCode = extractorService.GenerateInterface(
                             dialog.InterfaceName,
                             classInfo,
                             selectedMembers);
 
-                        // Save interface file
-                        var interfacesFolder = Path.Combine(Path.GetDirectoryName(filePath), Constants.InterfacesFolderName);
+                        var interfacesFolder = Path.Combine(Path.GetDirectoryName(filePath), options.InterfacesFolderName);
                         Directory.CreateDirectory(interfacesFolder);
 
                         var interfaceFilePath = Path.Combine(interfacesFolder, $"{dialog.InterfaceName}{Constants.CSharpExtension}");
 
-                        // Check if file exists
+                        // Show preview if enabled (v1.2.0)
+                        if (options.ShowPreviewBeforeSaving)
+                        {
+                            var previewDialog = new UI.PreviewDialog(
+                                dialog.InterfaceName,
+                                interfaceFilePath,
+                                interfaceCode);
+
+                            var previewResult = previewDialog.ShowDialog();
+
+                            if (previewResult != true || !previewDialog.UserApproved)
+                            {
+                                LogMessage($"  User cancelled after preview");
+                                skippedCount++;
+                                continue;
+                            }
+
+                            LogMessage($"  User approved preview");
+                        }
+
+                        // Handle existing file
                         if (File.Exists(interfaceFilePath))
                         {
                             bool shouldOverwrite = false;
@@ -292,33 +323,63 @@ private async Task ExecuteAsync()
                             }
                         }
 
+                        // Write interface file
                         File.WriteAllText(interfaceFilePath, interfaceCode);
                         LogMessage($"  Created: {interfaceFilePath}");
 
-                        // Update the original class to implement the interface
-                        try
+                        // Generate implementation stub if enabled (v1.2.0)
+                        if (options.GenerateImplementationStubs)
                         {
-                            var originalCode = File.ReadAllText(filePath);
-                            var updatedCode = Services.InterfaceExtractorService.AppendInterfaceToClass(
-                                originalCode,
-                                classInfo.ClassName,
+                            var stubClassName = $"{classInfo.ClassName}{options.ImplementationStubSuffix}";
+                            var stubCode = extractorService.GenerateImplementationStub(
                                 dialog.InterfaceName,
-                                $"{classInfo.Namespace}{Constants.InterfacesNamespaceSuffix}");
+                                stubClassName,
+                                classInfo,
+                                selectedMembers);
+
+                            var stubFilePath = Path.Combine(interfacesFolder, $"{stubClassName}{Constants.CSharpExtension}");
 
-                            if (updatedCode != originalCode)
+                            if (!File.Exists(stubFilePath) || overwriteChoice == OverwriteChoice.YesToAll)
                             {
-                                File.WriteAllText(filePath, updatedCode);
-                                LogMessage($"  Updated class to implement {dialog.InterfaceName}");
+                                File.WriteAllText(stubFilePath, stubCode);
+                                LogMessage($"  Created implementation stub: {stubFilePath}");
                             }
                             else
                             {
-                                LogMessage($"  Class already implements {dialog.InterfaceName}");
+                                LogMessage($"  Skipped implementation stub (file exists): {stubClassName}");
                             }
                         }
-                        catch (Exception ex)
+
+                        // Update class to implement interface
+                        if (options.AutoUpdateClass)
                         {
-                            LogMessage($"  Warning: Could not update class to implement interface: {ex.Message}");
-                            // Continue - interface was still created successfully
+                            try
+                            {
+                                var originalCode = File.ReadAllText(filePath);
+                                var updatedCode = extractorService.AppendInterfaceToClass(
+                                    originalCode,
+                                    classInfo.ClassName,
+                                    dialog.InterfaceName,
+                                    $"{classInfo.Namespace}{options.InterfacesNamespaceSuffix}");
+
+                                if (updatedCode != originalCode)
+                                {
+                                    File.WriteAllText(filePath, updatedCode);
+                                    LogMessage($"  Updated {typeKind} to implement {dialog.InterfaceName}");
+                                }
+                                else
+                                {
+                                    LogMessage($"  {typeKind.Substring(0, 1).ToUpper()}{typeKind.Substring(1)} already implements {dialog.InterfaceName}");
+                                }
+                            }
+                            catch (Exception ex)
+                            {
+                                LogMessage($"  Warning: Could not update {typeKind} to implement interface: {ex.Message}");
+                            }
+                        }
+                        else
+                        {
+                            LogMessage($"  Skipped {typeKind} update (disabled in options)");
                         }
 
                         // Add to project
@@ -332,31 +393,53 @@ private async Task ExecuteAsync()
                                     .FirstOrDefault(pi =>
                                     {
                                         ThreadHelper.ThrowIfNotOnUIThread();
-                                        return pi.Name == Constants.InterfacesFolderName;
-                                    }) ?? projectItems.AddFolder(Constants.InterfacesFolderName);
+                                        return pi.Name == options.InterfacesFolderName;
+                                    }) ?? projectItems.AddFolder(options.InterfacesFolderName);
 
-                                // Check if already in project
-                                var existingItem = interfacesFolderItem?.ProjectItems.Cast<ProjectItem>()
+                                // Add interface file
+                                var existingInterfaceItem = interfacesFolderItem?.ProjectItems.Cast<ProjectItem>()
                                     .FirstOrDefault(pi =>
                                     {
                                         ThreadHelper.ThrowIfNotOnUIThread();
                                         return pi.Name == $"{dialog.InterfaceName}{Constants.CSharpExtension}";
                                     });
 
-                                if (existingItem == null)
+                                if (existingInterfaceItem == null)
                                 {
                                     interfacesFolderItem?.ProjectItems.AddFromFile(interfaceFilePath);
-                                    LogMessage($"  Added to project");
+                                    LogMessage($"  Added interface to project");
                                 }
                                 else
                                 {
-                                    LogMessage($"  File already in project");
+                                    LogMessage($"  Interface file already in project");
+                                }
+
+                                // Add implementation stub file if generated
+                                if (options.GenerateImplementationStubs)
+                                {
+                                    var stubClassName = $"{classInfo.ClassName}{options.ImplementationStubSuffix}";
+                                    var stubFilePath = Path.Combine(interfacesFolder, $"{stubClassName}{Constants.CSharpExtension}");
+
+                                    if (File.Exists(stubFilePath))
+                                    {
+                                        var existingStubItem = interfacesFolderItem?.ProjectItems.Cast<ProjectItem>()
+                                            .FirstOrDefault(pi =>
+                                            {
+                                                ThreadHelper.ThrowIfNotOnUIThread();
+                                                return pi.Name == $"{stubClassName}{Constants.CSharpExtension}";
+                                            });
+
+                                        if (existingStubItem == null)
+                                        {
+                                            interfacesFolderItem?.ProjectItems.AddFromFile(stubFilePath);
+                                            LogMessage($"  Added implementation stub to project");
+                                        }
+                                    }
                                 }
                             }
                             catch (Exception ex)
                             {
-                                LogMessage($"  Warning: Could not add file to project: {ex.Message}");
-                                // File created successfully, just couldn't add to project
+                                LogMessage($"  Warning: Could not add file(s) to project: {ex.Message}");
                             }
                         }
 
@@ -383,6 +466,7 @@ private async Task ExecuteAsync()
                          $"Failed: {failCount}\n" +
                          $"Skipped: {skippedCount}";
 
+            LogMessage("=== Extraction Complete ===");
             LogMessage(summary.Replace("\n", " "));
 
             if (successCount > 0 || failCount > 0)
@@ -401,14 +485,12 @@ private static bool IsValidInterfaceName(string name, out string error)
                 return false;
             }
 
-            // Check if valid C# identifier
             if (!Microsoft.CodeAnalysis.CSharp.SyntaxFacts.IsValidIdentifier(name))
             {
                 error = "Interface name is not a valid C# identifier.";
                 return false;
             }
 
-            // Check if it's a reserved keyword
             if (Microsoft.CodeAnalysis.CSharp.SyntaxFacts.GetKeywordKind(name) != Microsoft.CodeAnalysis.CSharp.SyntaxKind.None)
             {
                 error = "Interface name cannot be a C# keyword.";
@@ -441,9 +523,6 @@ private static UI.OverwriteChoice ShowOverwriteConfirmation(string fileName)
         }
     }
 
-    /// <summary>
-    /// Represents the user's choice for overwriting files (internal tracking)
-    /// </summary>
     internal enum OverwriteChoice
     {
         Ask,
@@ -451,24 +530,15 @@ internal enum OverwriteChoice
         NoToAll
     }
 
-    /// <summary>
-    /// Extension methods for JoinableTask fire-and-forget operations
-    /// </summary>
     internal static class JoinableTaskExtensions
     {
-        /// <summary>
-        /// Allows fire-and-forget for JoinableTask while ensuring proper exception handling
-        /// </summary>
         public static void FileAndForget(this Microsoft.VisualStudio.Threading.JoinableTask joinableTask, string context)
         {
-            // JoinableTask already handles the async operation properly
-            // Just need to observe it to prevent unobserved task exceptions
             _ = joinableTask.Task.ContinueWith(
                 t =>
                 {
                     if (t.IsFaulted && t.Exception != null)
                     {
-                        // Log to activity log
                         ActivityLog.LogError(context, $"Unhandled exception: {t.Exception.InnerException?.Message ?? t.Exception.Message}");
                     }
                 },
diff --git a/InterfaceExtractor.Extension/InterfaceExtractor.Extension.csproj b/InterfaceExtractor.Extension/InterfaceExtractor.Extension.csproj
index 806bfe8..43b12d8 100644
--- a/InterfaceExtractor.Extension/InterfaceExtractor.Extension.csproj
+++ b/InterfaceExtractor.Extension/InterfaceExtractor.Extension.csproj
@@ -3,6 +3,7 @@
   <PropertyGroup>
     <MinimumVisualStudioVersion>17.0</MinimumVisualStudioVersion>
     <VSToolsPath Condition="'$(VSToolsPath)' == ''">$(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion)</VSToolsPath>
+    <RuntimeIdentifiers>win</RuntimeIdentifiers>
   </PropertyGroup>
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
@@ -48,11 +49,17 @@
     <Compile Include="Commands\ExtractInterfaceCommand.cs" />
     <Compile Include="Constants.cs" />
     <Compile Include="InterfaceExtractorPackage.cs" />
+    <Compile Include="Options\OptionsPage.cs">
+      <SubType>Component</SubType>
+    </Compile>
     <Compile Include="Services\InterfaceExtractorService.cs" />
     <Compile Include="UI\MemberSelectionItem.cs" />
     <Compile Include="UI\ExtractInterfaceDialog.xaml.cs">
       <DependentUpon>ExtractInterfaceDialog.xaml</DependentUpon>
     </Compile>
+    <Compile Include="UI\PreviewDialog.xaml.cs">
+      <DependentUpon>PreviewDialog.xaml</DependentUpon>
+    </Compile>
     <Compile Include="UI\OverwriteDialog.xaml.cs">
       <DependentUpon>OverwriteDialog.xaml</DependentUpon>
     </Compile>
@@ -68,6 +75,10 @@
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
     </Page>
+    <Page Include="UI\PreviewDialog.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+    </Page>
     <Page Include="UI\OverwriteDialog.xaml">
       <SubType>Designer</SubType>
       <Generator>MSBuild:Compile</Generator>
diff --git a/InterfaceExtractor.Extension/InterfaceExtractorPackage.cs b/InterfaceExtractor.Extension/InterfaceExtractorPackage.cs
index efcf80b..d292526 100644
--- a/InterfaceExtractor.Extension/InterfaceExtractorPackage.cs
+++ b/InterfaceExtractor.Extension/InterfaceExtractorPackage.cs
@@ -9,23 +9,10 @@ namespace InterfaceExtractor
     /// <summary>
     /// This is the class that implements the package exposed by this assembly.
     /// </summary>
-    /// <remarks>
-    /// <para>
-    /// The minimum requirement for a class to be considered a valid package for Visual Studio
-    /// is to implement the IVsPackage interface and register itself with the shell.
-    /// This package uses the helper classes defined inside the Managed Package Framework (MPF)
-    /// to do it: it derives from the Package class that provides the implementation of the
-    /// IVsPackage interface and uses the registration attributes defined in the framework to
-    /// register itself and its components with the shell. These attributes tell the pkgdef creation
-    /// utility what data to put into .pkgdef file.
-    /// </para>
-    /// <para>
-    /// To get loaded into VS, the package must be referred by &lt;Asset Type="Microsoft.VisualStudio.VsPackage" ...&gt; in .vsixmanifest file.
-    /// </para>
-    /// </remarks>
     [PackageRegistration(UseManagedResourcesOnly = true, AllowsBackgroundLoading = true)]
     [Guid(InterfaceExtractorPackage.PackageGuidString)]
     [ProvideMenuResource("Menus.ctmenu", 1)]
+    [ProvideOptionPage(typeof(Options.GeneralOptionsPage), "Interface Extractor", "General", 0, 0, true)]
     public sealed class InterfaceExtractorPackage : AsyncPackage
     {
         /// <summary>
diff --git a/InterfaceExtractor.Extension/Options/OptionsPage.cs b/InterfaceExtractor.Extension/Options/OptionsPage.cs
new file mode 100644
index 0000000..3f56cbf
--- /dev/null
+++ b/InterfaceExtractor.Extension/Options/OptionsPage.cs
@@ -0,0 +1,274 @@
+using Microsoft.VisualStudio.Shell;
+using System.ComponentModel;
+using System.Runtime.InteropServices;
+
+namespace InterfaceExtractor.Options
+{
+    /// <summary>
+    /// Options page for Interface Extractor settings (Visual Studio UI)
+    /// </summary>
+    [ComVisible(true)]
+    [Guid("A7B3C2D1-E4F5-6789-ABCD-EF0123456789")]
+    public class GeneralOptionsPage : DialogPage
+    {
+        private readonly ExtractorOptions _options = new ExtractorOptions();
+
+        [Category("General")]
+        [DisplayName("Interface Folder Name")]
+        [Description("The name of the folder where interface files will be created.")]
+        [DefaultValue("Interfaces")]
+        public string InterfacesFolderName
+        {
+            get => _options.InterfacesFolderName;
+            set => _options.InterfacesFolderName = value;
+        }
+
+        [Category("General")]
+        [DisplayName("Interface Prefix")]
+        [Description("The prefix to use when suggesting interface names (typically 'I').")]
+        [DefaultValue("I")]
+        public string InterfacePrefix
+        {
+            get => _options.InterfacePrefix;
+            set => _options.InterfacePrefix = value;
+        }
+
+        [Category("General")]
+        [DisplayName("Namespace Suffix")]
+        [Description("The suffix to append to the original namespace for interface files.")]
+        [DefaultValue(".Interfaces")]
+        public string InterfacesNamespaceSuffix
+        {
+            get => _options.InterfacesNamespaceSuffix;
+            set => _options.InterfacesNamespaceSuffix = value;
+        }
+
+        [Category("Behavior")]
+        [DisplayName("Automatically Update Class")]
+        [Description("Automatically add the interface to the class declaration after generation.")]
+        [DefaultValue(true)]
+        public bool AutoUpdateClass
+        {
+            get => _options.AutoUpdateClass;
+            set => _options.AutoUpdateClass = value;
+        }
+
+        [Category("Behavior")]
+        [DisplayName("Add Using Directive")]
+        [Description("Automatically add using directive for the interface namespace when updating the class.")]
+        [DefaultValue(true)]
+        public bool AddUsingDirective
+        {
+            get => _options.AddUsingDirective;
+            set => _options.AddUsingDirective = value;
+        }
+
+        [Category("Behavior")]
+        [DisplayName("Warn If No 'I' Prefix")]
+        [Description("Show a warning dialog if the interface name doesn't start with the configured prefix.")]
+        [DefaultValue(true)]
+        public bool WarnIfNoIPrefix
+        {
+            get => _options.WarnIfNoIPrefix;
+            set => _options.WarnIfNoIPrefix = value;
+        }
+
+        [Category("Behavior")]
+        [DisplayName("Include Operator Overloads")]
+        [Description("Include operator overloads (==, !=, +, -, etc.) when extracting interfaces.")]
+        [DefaultValue(false)]
+        public bool IncludeOperatorOverloads
+        {
+            get => _options.IncludeOperatorOverloads;
+            set => _options.IncludeOperatorOverloads = value;
+        }
+
+        [Category("Behavior")]
+        [DisplayName("Show Preview Before Saving")]
+        [Description("Display a preview of the generated interface before saving to disk.")]
+        [DefaultValue(true)]
+        public bool ShowPreviewBeforeSaving
+        {
+            get => _options.ShowPreviewBeforeSaving;
+            set => _options.ShowPreviewBeforeSaving = value;
+        }
+
+        [Category("Behavior")]
+        [DisplayName("Include Internal Members")]
+        [Description("Include internal members in addition to public members when extracting interfaces.")]
+        [DefaultValue(false)]
+        public bool IncludeInternalMembers
+        {
+            get => _options.IncludeInternalMembers;
+            set => _options.IncludeInternalMembers = value;
+        }
+
+        [Category("Behavior")]
+        [DisplayName("Analyze Partial Classes")]
+        [Description("When extracting from partial classes, analyze all partial files to include all members.")]
+        [DefaultValue(true)]
+        public bool AnalyzePartialClasses
+        {
+            get => _options.AnalyzePartialClasses;
+            set => _options.AnalyzePartialClasses = value;
+        }
+
+        [Category("Code Generation")]
+        [DisplayName("Generate Implementation Stubs")]
+        [Description("Generate a file with empty implementation stubs for the interface members.")]
+        [DefaultValue(false)]
+        public bool GenerateImplementationStubs
+        {
+            get => _options.GenerateImplementationStubs;
+            set => _options.GenerateImplementationStubs = value;
+        }
+
+        [Category("Code Generation")]
+        [DisplayName("Implementation Stub Suffix")]
+        [Description("Suffix to append to implementation stub class names (e.g., 'Implementation', 'Service').")]
+        [DefaultValue("Implementation")]
+        public string ImplementationStubSuffix
+        {
+            get => _options.ImplementationStubSuffix;
+            set => _options.ImplementationStubSuffix = value;
+        }
+
+        [Category("Templates")]
+        [DisplayName("Include File Header")]
+        [Description("Include a header comment at the top of generated interface files.")]
+        [DefaultValue(false)]
+        public bool IncludeFileHeader
+        {
+            get => _options.IncludeFileHeader;
+            set => _options.IncludeFileHeader = value;
+        }
+
+        [Category("Templates")]
+        [DisplayName("File Header Template")]
+        [Description("The template for file headers. Use {FileName}, {Date}, {Time} placeholders.")]
+        [DefaultValue("// Generated by Interface Extractor on {Date} at {Time}\n// File: {FileName}")]
+        public string FileHeaderTemplate
+        {
+            get => _options.FileHeaderTemplate;
+            set => _options.FileHeaderTemplate = value;
+        }
+
+        [Category("Templates")]
+        [DisplayName("Member Separator Lines")]
+        [Description("Number of blank lines between interface members (0-3).")]
+        [DefaultValue(1)]
+        public int MemberSeparatorLines
+        {
+            get => _options.MemberSeparatorLines;
+            set => _options.MemberSeparatorLines = value;
+        }
+
+        [Category("Templates")]
+        [DisplayName("Sort Members")]
+        [Description("Sort interface members alphabetically by type and name.")]
+        [DefaultValue(false)]
+        public bool SortMembers
+        {
+            get => _options.SortMembers;
+            set => _options.SortMembers = value;
+        }
+
+        [Category("Templates")]
+        [DisplayName("Group By Member Type")]
+        [Description("Group interface members by type (Properties, Methods, Events, Indexers, Operators).")]
+        [DefaultValue(false)]
+        public bool GroupByMemberType
+        {
+            get => _options.GroupByMemberType;
+            set => _options.GroupByMemberType = value;
+        }
+
+        /// <summary>
+        /// Gets the underlying options data model
+        /// </summary>
+        public ExtractorOptions GetOptions()
+        {
+            return _options;
+        }
+
+        /// <summary>
+        /// Validates settings when applied
+        /// </summary>
+        protected override void OnApply(PageApplyEventArgs e)
+        {
+            // Validate folder name
+            if (string.IsNullOrWhiteSpace(InterfacesFolderName))
+            {
+                e.ApplyBehavior = ApplyKind.CancelNoNavigate;
+                return;
+            }
+
+            // Validate prefix
+            if (InterfacePrefix != null && InterfacePrefix.Length > 5)
+            {
+                e.ApplyBehavior = ApplyKind.CancelNoNavigate;
+                return;
+            }
+
+            // Validate separator lines
+            if (MemberSeparatorLines < 0 || MemberSeparatorLines > 3)
+            {
+                MemberSeparatorLines = 1;
+            }
+
+            // Validate implementation stub suffix
+            if (string.IsNullOrWhiteSpace(ImplementationStubSuffix))
+            {
+                ImplementationStubSuffix = "Implementation";
+            }
+
+            base.OnApply(e);
+        }
+    }
+
+    /// <summary>
+    /// Options data model - can be used without Visual Studio dependencies
+    /// </summary>
+    public class ExtractorOptions
+    {
+        public string InterfacesFolderName { get; set; } = "Interfaces";
+        public string InterfacePrefix { get; set; } = "I";
+        public string InterfacesNamespaceSuffix { get; set; } = ".Interfaces";
+        public bool AutoUpdateClass { get; set; } = true;
+        public bool AddUsingDirective { get; set; } = true;
+        public bool WarnIfNoIPrefix { get; set; } = true;
+        public bool IncludeOperatorOverloads { get; set; } = false;
+        public bool ShowPreviewBeforeSaving { get; set; } = true;
+        public bool IncludeInternalMembers { get; set; } = false;
+        public bool AnalyzePartialClasses { get; set; } = true;
+        public bool GenerateImplementationStubs { get; set; } = false;
+        public string ImplementationStubSuffix { get; set; } = "Implementation";
+        public bool IncludeFileHeader { get; set; } = false;
+        public string FileHeaderTemplate { get; set; } = "// Generated by Interface Extractor on {Date} at {Time}\n// File: {FileName}";
+        public int MemberSeparatorLines { get; set; } = 1;
+        public bool SortMembers { get; set; } = false;
+        public bool GroupByMemberType { get; set; } = false;
+    }
+
+    /// <summary>
+    /// Static accessor for options
+    /// </summary>
+    public static class OptionsProvider
+    {
+        private static GeneralOptionsPage _optionsPage;
+
+        public static ExtractorOptions GetOptions(Package package)
+        {
+            if (_optionsPage == null && package != null)
+            {
+                _optionsPage = (GeneralOptionsPage)package.GetDialogPage(typeof(GeneralOptionsPage));
+            }
+            return _optionsPage?.GetOptions() ?? new ExtractorOptions();
+        }
+
+        public static void ClearCache()
+        {
+            _optionsPage = null;
+        }
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Extension/Services/InterfaceExtractorService.cs b/InterfaceExtractor.Extension/Services/InterfaceExtractorService.cs
index 40ff19f..78c8e03 100644
--- a/InterfaceExtractor.Extension/Services/InterfaceExtractorService.cs
+++ b/InterfaceExtractor.Extension/Services/InterfaceExtractorService.cs
@@ -1,6 +1,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
+using InterfaceExtractor.Options;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -12,12 +13,19 @@ namespace InterfaceExtractor.Services
 {
     public class InterfaceExtractorService
     {
-        public async Task<List<ExtractedClassInfo>> AnalyzeClassesAsync(string filePath)
+        private readonly ExtractorOptions _options;
+
+        public InterfaceExtractorService(ExtractorOptions options = null)
+        {
+            _options = options ?? new ExtractorOptions();
+        }
+
+        public async Task<List<ExtractedClassInfo>> AnalyzeClassesAsync(string filePath, string projectDirectory = null)
         {
-            return await Task.Run(() => AnalyzeClasses(filePath));
+            return await Task.Run(() => AnalyzeClasses(filePath, projectDirectory));
         }
 
-        private List<ExtractedClassInfo> AnalyzeClasses(string filePath)
+        private List<ExtractedClassInfo> AnalyzeClasses(string filePath, string projectDirectory = null)
         {
             try
             {
@@ -25,15 +33,22 @@ private List<ExtractedClassInfo> AnalyzeClasses(string filePath)
                 var tree = CSharpSyntaxTree.ParseText(sourceCode);
                 var root = tree.GetRoot();
 
-                // Find all public classes
-                var classDeclarations = root.DescendantNodes()
+                // Find all public (and optionally internal) classes and records
+                var typeDeclarations = new List<TypeDeclarationSyntax>();
+
+                // Add classes
+                typeDeclarations.AddRange(root.DescendantNodes()
                     .OfType<ClassDeclarationSyntax>()
-                    .Where(c => c.Modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword)))
-                    .ToList();
+                    .Where(c => IsAccessible(c.Modifiers)));
+
+                // Add records (v1.2.0 feature)
+                typeDeclarations.AddRange(root.DescendantNodes()
+                    .OfType<RecordDeclarationSyntax>()
+                    .Where(r => IsAccessible(r.Modifiers)));
 
-                if (!classDeclarations.Any())
+                if (!typeDeclarations.Any())
                 {
-                    return new List<ExtractedClassInfo>(); // Return empty collection instead of null
+                    return new List<ExtractedClassInfo>();
                 }
 
                 var results = new List<ExtractedClassInfo>();
@@ -45,29 +60,47 @@ private List<ExtractedClassInfo> AnalyzeClasses(string filePath)
                     .Distinct()
                     .ToList();
 
-                foreach (var classDeclaration in classDeclarations)
+                foreach (var typeDeclaration in typeDeclarations)
                 {
-                    var className = classDeclaration.Identifier.Text;
+                    var typeName = typeDeclaration.Identifier.Text;
+                    var isPartial = typeDeclaration.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword));
+                    var isRecord = typeDeclaration is RecordDeclarationSyntax;
 
-                    // Extract namespace - simplified condition
-                    var namespaceDeclaration = classDeclaration.Ancestors()
+                    // Extract namespace
+                    var namespaceDeclaration = typeDeclaration.Ancestors()
                         .OfType<BaseNamespaceDeclarationSyntax>()
                         .FirstOrDefault();
 
                     var namespaceName = namespaceDeclaration?.Name.ToString() ?? "DefaultNamespace";
 
-                    // Extract public members
-                    var members = ExtractPublicMembers(classDeclaration);
+                    // Extract public members from current file
+                    var members = ExtractPublicMembers(typeDeclaration);
+
+                    // Handle partial classes (v1.2.0 feature)
+                    if (isPartial && _options.AnalyzePartialClasses && !string.IsNullOrEmpty(projectDirectory))
+                    {
+                        var partialMembers = AnalyzePartialClassFiles(
+                            typeName,
+                            namespaceName,
+                            projectDirectory,
+                            filePath);
+
+                        // Merge members, avoiding duplicates
+                        var newMembers = partialMembers.Where(pm => !members.Any(m => m.Signature == pm.Signature));
+                        members.AddRange(newMembers);
+                    }
 
                     if (members.Any())
                     {
                         results.Add(new ExtractedClassInfo
                         {
-                            ClassName = className,
+                            ClassName = typeName,
                             Namespace = namespaceName,
                             Members = members,
                             Usings = usings,
-                            FilePath = filePath
+                            FilePath = filePath,
+                            IsPartial = isPartial,
+                            IsRecord = isRecord
                         });
                     }
                 }
@@ -80,41 +113,170 @@ private List<ExtractedClassInfo> AnalyzeClasses(string filePath)
             }
         }
 
-        public static string GenerateInterface(string interfaceName, ExtractedClassInfo classInfo, List<MemberInfo> selectedMembers)
+        private bool IsAccessible(SyntaxTokenList modifiers)
+        {
+            var isPublic = modifiers.Any(m => m.IsKind(SyntaxKind.PublicKeyword));
+            var isInternal = modifiers.Any(m => m.IsKind(SyntaxKind.InternalKeyword));
+
+            if (isPublic)
+                return true;
+
+            // Include internal if option is enabled
+            if (_options.IncludeInternalMembers && isInternal)
+                return true;
+
+            // If no explicit accessibility, it's internal by default for types
+            if (_options.IncludeInternalMembers && !modifiers.Any(m =>
+                m.IsKind(SyntaxKind.PublicKeyword) ||
+                m.IsKind(SyntaxKind.PrivateKeyword) ||
+                m.IsKind(SyntaxKind.ProtectedKeyword) ||
+                m.IsKind(SyntaxKind.InternalKeyword)))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        private List<MemberInfo> AnalyzePartialClassFiles(string className, string namespaceName, string projectDirectory, string currentFile)
+        {
+            var additionalMembers = new List<MemberInfo>();
+
+            try
+            {
+                // Search for other .cs files in the project
+                var csFiles = Directory.GetFiles(projectDirectory, "*.cs", SearchOption.AllDirectories)
+                    .Where(f => !f.Equals(currentFile, StringComparison.OrdinalIgnoreCase))
+                    .ToList();
+
+                foreach (var file in csFiles)
+                {
+                    try
+                    {
+                        var sourceCode = File.ReadAllText(file);
+                        var tree = CSharpSyntaxTree.ParseText(sourceCode);
+                        var root = tree.GetRoot();
+
+                        // Find partial class/record with matching name and namespace
+                        var partialTypes = root.DescendantNodes()
+                            .OfType<TypeDeclarationSyntax>()
+                            .Where(t => t.Identifier.Text == className &&
+                                       t.Modifiers.Any(m => m.IsKind(SyntaxKind.PartialKeyword)) &&
+                                       IsAccessible(t.Modifiers))
+                            .ToList();
+
+                        foreach (var partialType in partialTypes)
+                        {
+                            var ns = partialType.Ancestors()
+                                .OfType<BaseNamespaceDeclarationSyntax>()
+                                .FirstOrDefault()?.Name.ToString() ?? "DefaultNamespace";
+
+                            if (ns == namespaceName)
+                            {
+                                var members = ExtractPublicMembers(partialType);
+                                additionalMembers.AddRange(members);
+                            }
+                        }
+                    }
+                    catch
+                    {
+                        // Skip files that can't be parsed
+                    }
+                }
+            }
+            catch
+            {
+                // If we can't scan for partial files, just continue with what we have
+            }
+
+            return additionalMembers;
+        }
+
+        public string GenerateInterface(string interfaceName, ExtractedClassInfo classInfo, List<MemberInfo> selectedMembers)
         {
             var sb = new StringBuilder();
 
-            // Add usings
-            foreach (var usingDirective in classInfo.Usings)
+            // Add file header if enabled
+            if (_options.IncludeFileHeader && !string.IsNullOrWhiteSpace(_options.FileHeaderTemplate))
+            {
+                var header = _options.FileHeaderTemplate
+                    .Replace("{FileName}", $"{interfaceName}.cs")
+                    .Replace("{Date}", DateTime.Now.ToString("yyyy-MM-dd"))
+                    .Replace("{Time}", DateTime.Now.ToString("HH:mm:ss"))
+                    .Replace("\\n", "\n");
+
+                sb.AppendLine(header);
+                sb.AppendLine();
+            }
+
+            // Calculate target namespace
+            var targetNamespace = $"{classInfo.Namespace}{_options.InterfacesNamespaceSuffix}";
+
+            // Filter out usings that match the target namespace
+            var filteredUsings = classInfo.Usings
+                .Where(u => !u.Contains($"using {targetNamespace};"))
+                .ToList();
+
+            // Add filtered usings
+            foreach (var usingDirective in filteredUsings)
             {
                 sb.AppendLine(usingDirective);
             }
 
-            if (classInfo.Usings.Any())
+            if (filteredUsings.Any())
             {
                 sb.AppendLine();
             }
 
             // Start namespace
-            sb.AppendLine($"namespace {classInfo.Namespace}{Constants.InterfacesNamespaceSuffix}");
+            sb.AppendLine($"namespace {classInfo.Namespace}{_options.InterfacesNamespaceSuffix}");
             sb.AppendLine("{");
 
             // Start interface
             sb.AppendLine($"    public interface {interfaceName}");
             sb.AppendLine("    {");
 
-            // Add selected members
-            for (int i = 0; i < selectedMembers.Count; i++)
+            // Sort and group members if requested
+            var membersToGenerate = selectedMembers.ToList();
+
+            if (_options.SortMembers)
             {
-                var member = selectedMembers[i];
+                membersToGenerate = membersToGenerate
+                    .OrderBy(m => m.Type)
+                    .ThenBy(m => m.Name)
+                    .ToList();
+            }
 
-                // Add blank line between members except for first one
+            if (_options.GroupByMemberType)
+            {
+                membersToGenerate = membersToGenerate
+                    .OrderBy(m => GetMemberTypeOrder(m.Type))
+                    .ThenBy(m => m.Name)
+                    .ToList();
+            }
+
+            // Add members
+            for (int i = 0; i < membersToGenerate.Count; i++)
+            {
+                var member = membersToGenerate[i];
+
+                // Add separator lines between members
                 if (i > 0)
                 {
-                    sb.AppendLine();
+                    for (int j = 0; j < _options.MemberSeparatorLines; j++)
+                    {
+                        sb.AppendLine();
+                    }
+                }
+
+                // Add group comment if grouping is enabled
+                if (_options.GroupByMemberType &&
+                    (i == 0 || membersToGenerate[i - 1].Type != member.Type))
+                {
+                    sb.AppendLine($"        // {GetMemberTypeGroupName(member.Type)}");
                 }
 
-                // Add XML documentation comment if available
+                // Add XML documentation
                 if (!string.IsNullOrWhiteSpace(member.Documentation))
                 {
                     foreach (var line in member.Documentation.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries))
@@ -122,7 +284,6 @@ public static string GenerateInterface(string interfaceName, ExtractedClassInfo
                         var trimmedLine = line.Trim();
                         if (!string.IsNullOrWhiteSpace(trimmedLine))
                         {
-                            // Ensure the line starts with ///
                             if (trimmedLine.StartsWith("///"))
                             {
                                 sb.AppendLine($"        {trimmedLine}");
@@ -143,36 +304,189 @@ public static string GenerateInterface(string interfaceName, ExtractedClassInfo
                 }
                 else
                 {
-                    // Only add semicolon if the signature doesn't end with }
-                    // Properties/indexers with accessor blocks end with }, methods/events don't
                     var needsSemicolon = !member.Signature.TrimEnd().EndsWith("}");
+                    sb.AppendLine(needsSemicolon
+                        ? $"        {member.Signature};"
+                        : $"        {member.Signature}");
+                }
+            }
 
-                    if (needsSemicolon)
-                    {
-                        sb.AppendLine($"        {member.Signature};");
-                    }
-                    else
+            // Close interface and namespace
+            sb.AppendLine("    }");
+            sb.AppendLine("}");
+
+            return sb.ToString();
+        }
+
+        public string GenerateImplementationStub(string interfaceName, string className, ExtractedClassInfo classInfo, List<MemberInfo> selectedMembers)
+        {
+            var sb = new StringBuilder();
+
+            // Add file header if enabled
+            if (_options.IncludeFileHeader && !string.IsNullOrWhiteSpace(_options.FileHeaderTemplate))
+            {
+                var header = _options.FileHeaderTemplate
+                    .Replace("{FileName}", $"{className}.cs")
+                    .Replace("{Date}", DateTime.Now.ToString("yyyy-MM-dd"))
+                    .Replace("{Time}", DateTime.Now.ToString("HH:mm:ss"))
+                    .Replace("\\n", "\n");
+
+                sb.AppendLine(header);
+                sb.AppendLine();
+            }
+
+            var targetNamespace = $"{classInfo.Namespace}{_options.InterfacesNamespaceSuffix}";
+
+            // Add usings
+            foreach (var usingDirective in classInfo.Usings)
+            {
+                sb.AppendLine(usingDirective);
+            }
+
+            // Add using for interface namespace if different
+            if (classInfo.Namespace != targetNamespace)
+            {
+                sb.AppendLine($"using {targetNamespace};");
+            }
+
+            if (classInfo.Usings.Any())
+            {
+                sb.AppendLine();
+            }
+
+            // Start namespace
+            sb.AppendLine($"namespace {classInfo.Namespace}");
+            sb.AppendLine("{");
+
+            // Start class
+            sb.AppendLine($"    public class {className} : {interfaceName}");
+            sb.AppendLine("    {");
+
+            // Generate stubs for each member
+            foreach (var member in selectedMembers)
+            {
+                sb.AppendLine();
+
+                // Add XML documentation
+                if (!string.IsNullOrWhiteSpace(member.Documentation))
+                {
+                    foreach (var line in member.Documentation.Split(new[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries))
                     {
-                        sb.AppendLine($"        {member.Signature}");
+                        var trimmedLine = line.Trim();
+                        if (!string.IsNullOrWhiteSpace(trimmedLine))
+                        {
+                            if (trimmedLine.StartsWith("///"))
+                            {
+                                sb.AppendLine($"        {trimmedLine}");
+                            }
+                            else
+                            {
+                                sb.AppendLine($"        /// {trimmedLine}");
+                            }
+                        }
                     }
                 }
+
+                switch (member.Type)
+                {
+                    case MemberType.Method:
+                        GenerateMethodStub(sb, member);
+                        break;
+
+                    case MemberType.Property:
+                        GeneratePropertyStub(sb, member);
+                        break;
+
+                    case MemberType.Event:
+                        GenerateEventStub(sb, member);
+                        break;
+
+                    case MemberType.Indexer:
+                        GenerateIndexerStub(sb, member);
+                        break;
+                }
             }
 
-            // Close interface and namespace
+            // Close class and namespace
             sb.AppendLine("    }");
             sb.AppendLine("}");
 
             return sb.ToString();
         }
 
-        private List<MemberInfo> ExtractPublicMembers(ClassDeclarationSyntax classDeclaration)
+        private static void GenerateMethodStub(StringBuilder sb, MemberInfo member)
+        {
+            if (!string.IsNullOrWhiteSpace(member.Constraints))
+            {
+                sb.AppendLine($"        public {member.Signature}");
+                sb.AppendLine($"            {member.Constraints}");
+            }
+            else
+            {
+                sb.AppendLine($"        public {member.Signature}");
+            }
+
+            sb.AppendLine("        {");
+
+            // Add appropriate return statement or throw NotImplementedException
+            if (member.ReturnType == "Task")
+            {
+                sb.AppendLine($"            return Task.CompletedTask;");
+            }
+            else if (member.ReturnType != "void")
+            {
+                sb.AppendLine($"            throw new System.NotImplementedException();");
+            }
+
+            sb.AppendLine("        }");
+        }
+
+        private static void GeneratePropertyStub(StringBuilder sb, MemberInfo member)
+        {
+            sb.AppendLine($"        public {member.Signature}");
+        }
+
+        private static void GenerateEventStub(StringBuilder sb, MemberInfo member)
+        {
+            sb.AppendLine($"        public {member.Signature};");
+        }
+
+        private static void GenerateIndexerStub(StringBuilder sb, MemberInfo member)
+        {
+            sb.AppendLine($"        public {member.Signature}");
+        }
+
+        private List<MemberInfo> ExtractPublicMembers(TypeDeclarationSyntax typeDeclaration)
         {
             var members = new List<MemberInfo>();
 
-            // Extract public methods - simplified with Where clause
-            var methods = classDeclaration.Members
+            // Extract primary constructor parameters from records (v1.2.0)
+            if (typeDeclaration is RecordDeclarationSyntax recordDeclaration &&
+                recordDeclaration.ParameterList != null)
+            {
+                foreach (var parameter in recordDeclaration.ParameterList.Parameters)
+                {
+                    var paramType = parameter.Type.ToString();
+                    var paramName = parameter.Identifier.Text;
+
+                    // Extract documentation from parameter if available
+                    var documentation = ExtractDocumentation(parameter);
+
+                    members.Add(new MemberInfo
+                    {
+                        Type = MemberType.Property,
+                        Signature = $"{paramType} {paramName} {{ get; }}",
+                        Name = paramName,
+                        ReturnType = paramType,
+                        Documentation = documentation
+                    });
+                }
+            }
+
+            // Extract methods
+            var methods = typeDeclaration.Members
                 .OfType<MethodDeclarationSyntax>()
-                .Where(m => m.Modifiers.Any(mod => mod.IsKind(SyntaxKind.PublicKeyword)) &&
+                .Where(m => IsAccessible(m.Modifiers) &&
                            !m.Modifiers.Any(mod => mod.IsKind(SyntaxKind.StaticKeyword)));
 
             foreach (var method in methods)
@@ -195,10 +509,10 @@ private List<MemberInfo> ExtractPublicMembers(ClassDeclarationSyntax classDeclar
                 });
             }
 
-            // Extract public properties - simplified with Where clause
-            var properties = classDeclaration.Members
+            // Extract properties
+            var properties = typeDeclaration.Members
                 .OfType<PropertyDeclarationSyntax>()
-                .Where(p => p.Modifiers.Any(mod => mod.IsKind(SyntaxKind.PublicKeyword)) &&
+                .Where(p => IsAccessible(p.Modifiers) &&
                            !p.Modifiers.Any(mod => mod.IsKind(SyntaxKind.StaticKeyword)));
 
             foreach (var property in properties)
@@ -207,24 +521,28 @@ private List<MemberInfo> ExtractPublicMembers(ClassDeclarationSyntax classDeclar
                 var propName = property.Identifier.Text;
                 var documentation = ExtractDocumentation(property);
 
-                // Simplified accessor logic using LINQ Where
                 var accessors = new List<string>();
                 if (property.AccessorList != null)
                 {
                     accessors = property.AccessorList.Accessors
                         .Where(accessor => !accessor.Modifiers.Any(m => m.IsKind(SyntaxKind.PrivateKeyword)))
-                        .Select(accessor => accessor.Keyword.Text)
+                        .Select(accessor =>
+                        {
+                            var keyword = accessor.Keyword.Text;
+                            // Convert 'init' to 'get' for broader compatibility (init accessors in interfaces require implementing types to use init accessors; not supported in all C# versions)
+                            return keyword == "init" ? "get" : keyword;
+                        })
+                        .Distinct() // Remove duplicates if both get and init exist
                         .ToList();
                 }
                 else if (property.ExpressionBody != null)
                 {
-                    // Expression-bodied property (read-only)
                     accessors.Add("get");
                 }
 
                 var accessorList = accessors.Any()
                     ? $" {{ {string.Join("; ", accessors)}; }}"
-                    : " { get; }"; // Default to read-only
+                    : " { get; }";
 
                 members.Add(new MemberInfo
                 {
@@ -236,10 +554,10 @@ private List<MemberInfo> ExtractPublicMembers(ClassDeclarationSyntax classDeclar
                 });
             }
 
-            // Extract public events - simplified with Where clause
-            var events = classDeclaration.Members
+            // Extract events
+            var events = typeDeclaration.Members
                 .OfType<EventFieldDeclarationSyntax>()
-                .Where(e => e.Modifiers.Any(mod => mod.IsKind(SyntaxKind.PublicKeyword)) &&
+                .Where(e => IsAccessible(e.Modifiers) &&
                            !e.Modifiers.Any(mod => mod.IsKind(SyntaxKind.StaticKeyword)));
 
             foreach (var eventField in events)
@@ -262,10 +580,10 @@ private List<MemberInfo> ExtractPublicMembers(ClassDeclarationSyntax classDeclar
                 }
             }
 
-            // Extract public indexers - simplified with Where clause
-            var indexers = classDeclaration.Members
+            // Extract indexers
+            var indexers = typeDeclaration.Members
                 .OfType<IndexerDeclarationSyntax>()
-                .Where(i => i.Modifiers.Any(mod => mod.IsKind(SyntaxKind.PublicKeyword)) &&
+                .Where(i => IsAccessible(i.Modifiers) &&
                            !i.Modifiers.Any(mod => mod.IsKind(SyntaxKind.StaticKeyword)));
 
             foreach (var indexer in indexers)
@@ -274,7 +592,6 @@ private List<MemberInfo> ExtractPublicMembers(ClassDeclarationSyntax classDeclar
                 var parameters = indexer.ParameterList.ToString();
                 var documentation = ExtractDocumentation(indexer);
 
-                // Simplified accessor logic using LINQ Where
                 var accessors = new List<string>();
                 if (indexer.AccessorList != null)
                 {
@@ -298,110 +615,166 @@ private List<MemberInfo> ExtractPublicMembers(ClassDeclarationSyntax classDeclar
                 });
             }
 
+            // Extract operator overloads (if enabled)
+            if (_options.IncludeOperatorOverloads)
+            {
+                var operators = typeDeclaration.Members
+                    .OfType<OperatorDeclarationSyntax>()
+                    .Where(o => IsAccessible(o.Modifiers));
+
+                foreach (var op in operators)
+                {
+                    var returnType = op.ReturnType.ToString();
+                    var operatorToken = op.OperatorToken.Text;
+                    var parameters = op.ParameterList.ToString();
+                    var documentation = ExtractDocumentation(op);
+
+                    members.Add(new MemberInfo
+                    {
+                        Type = MemberType.Operator,
+                        Signature = $"{returnType} operator {operatorToken}{parameters}",
+                        Name = $"operator {operatorToken}",
+                        ReturnType = returnType,
+                        Documentation = documentation
+                    });
+                }
+
+                // Extract conversion operators
+                var conversions = typeDeclaration.Members
+                    .OfType<ConversionOperatorDeclarationSyntax>()
+                    .Where(c => IsAccessible(c.Modifiers));
+
+                foreach (var conversion in conversions)
+                {
+                    var conversionType = conversion.Type.ToString();
+                    var implicitOrExplicit = conversion.ImplicitOrExplicitKeyword.Text;
+                    var parameters = conversion.ParameterList.ToString();
+                    var documentation = ExtractDocumentation(conversion);
+
+                    members.Add(new MemberInfo
+                    {
+                        Type = MemberType.Operator,
+                        Signature = $"{implicitOrExplicit} operator {conversionType}{parameters}",
+                        Name = $"{implicitOrExplicit} operator {conversionType}",
+                        ReturnType = conversionType,
+                        Documentation = documentation
+                    });
+                }
+            }
+
             return members;
         }
 
+        private static string ExtractDocumentation(ParameterSyntax parameter)
+        {
+            var trivia = parameter.GetLeadingTrivia()
+                .FirstOrDefault(t => t.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) ||
+                                    t.IsKind(SyntaxKind.MultiLineDocumentationCommentTrivia));
+
+            return trivia != default ? trivia.ToString().Trim() : string.Empty;
+        }
+
         private static string ExtractDocumentation(MemberDeclarationSyntax member)
         {
             var trivia = member.GetLeadingTrivia()
                 .FirstOrDefault(t => t.IsKind(SyntaxKind.SingleLineDocumentationCommentTrivia) ||
                                     t.IsKind(SyntaxKind.MultiLineDocumentationCommentTrivia));
 
-            if (trivia != default)
-            {
-                return trivia.ToString().Trim();
-            }
-
-            return string.Empty;
+            return trivia != default ? trivia.ToString().Trim() : string.Empty;
         }
 
-        /// <summary>
-        /// Appends the interface to the class declaration
-        /// </summary>
-        public static string AppendInterfaceToClass(string sourceCode, string className, string interfaceName, string interfaceNamespace)
+        public string AppendInterfaceToClass(string sourceCode, string className, string interfaceName, string interfaceNamespace)
         {
+            if (!_options.AutoUpdateClass)
+            {
+                return sourceCode;
+            }
+
             var tree = CSharpSyntaxTree.ParseText(sourceCode);
             var root = (CompilationUnitSyntax)tree.GetRoot();
 
-            // Find the target class
-            var classDeclaration = root.DescendantNodes()
+            // Find class or record
+            TypeDeclarationSyntax typeDeclaration = root.DescendantNodes()
                 .OfType<ClassDeclarationSyntax>()
                 .FirstOrDefault(c => c.Identifier.Text == className);
 
-            if (classDeclaration == null)
+            if (typeDeclaration == null)
+            {
+                typeDeclaration = root.DescendantNodes()
+                    .OfType<RecordDeclarationSyntax>()
+                    .FirstOrDefault(r => r.Identifier.Text == className);
+            }
+
+            if (typeDeclaration == null)
             {
-                return sourceCode; // Class not found, return original
+                return sourceCode;
             }
 
-            // Get the class's namespace
-            var classNamespace = classDeclaration.Ancestors()
+            var classNamespace = typeDeclaration.Ancestors()
                 .OfType<BaseNamespaceDeclarationSyntax>()
                 .FirstOrDefault();
 
             var classNamespaceName = classNamespace?.Name.ToString() ?? "";
 
-            // Determine if we need to use fully qualified name
+            // Determine interface name to use
             string interfaceToAdd;
-            if (classNamespaceName == interfaceNamespace ||
-                string.IsNullOrEmpty(interfaceNamespace))
+            bool sameNamespace = classNamespaceName == interfaceNamespace || string.IsNullOrEmpty(interfaceNamespace);
+
+            if (sameNamespace)
+            {
+                interfaceToAdd = interfaceName;
+            }
+            else if (_options.AddUsingDirective)
             {
-                // Same namespace, use simple name
                 interfaceToAdd = interfaceName;
             }
             else
             {
-                // Different namespace, use fully qualified name
                 interfaceToAdd = $"{interfaceNamespace}.{interfaceName}";
             }
 
-            // Check if interface is already implemented
-            if (classDeclaration.BaseList != null)
+            if (typeDeclaration.BaseList != null)
             {
-                var existingBases = classDeclaration.BaseList.Types
+                var existingBases = typeDeclaration.BaseList.Types
                     .Select(t => t.ToString())
                     .ToList();
 
                 if (existingBases.Any(b => b.Contains(interfaceName)))
                 {
-                    return sourceCode; // Already implements this interface
+                    return sourceCode;
                 }
             }
 
-            // Add the interface to the base list
-            ClassDeclarationSyntax newClassDeclaration;
+            TypeDeclarationSyntax newTypeDeclaration;
 
-            if (classDeclaration.BaseList == null)
+            if (typeDeclaration.BaseList == null)
             {
-                // No base list, create one
                 var baseType = SyntaxFactory.SimpleBaseType(
                     SyntaxFactory.ParseTypeName(interfaceToAdd));
 
                 var baseList = SyntaxFactory.BaseList(
                     SyntaxFactory.SingletonSeparatedList<BaseTypeSyntax>(baseType));
 
-                newClassDeclaration = classDeclaration.WithBaseList(baseList);
+                newTypeDeclaration = typeDeclaration.WithBaseList(baseList);
             }
             else
             {
-                // Add to existing base list
                 var baseType = SyntaxFactory.SimpleBaseType(
                     SyntaxFactory.ParseTypeName(interfaceToAdd));
 
-                var newBaseList = classDeclaration.BaseList.AddTypes(baseType);
-                newClassDeclaration = classDeclaration.WithBaseList(newBaseList);
+                var newBaseList = typeDeclaration.BaseList.AddTypes(baseType);
+                newTypeDeclaration = typeDeclaration.WithBaseList(newBaseList);
             }
 
-            // Replace the old class with the new one
-            var newRoot = root.ReplaceNode(classDeclaration, newClassDeclaration);
+            var newRoot = root.ReplaceNode(typeDeclaration, newTypeDeclaration);
 
-            // Add using directive if needed (for different namespace)
-            if (classNamespaceName != interfaceNamespace &&
+            if (_options.AddUsingDirective &&
+                !sameNamespace &&
                 !string.IsNullOrEmpty(interfaceNamespace))
             {
                 var usingDirective = SyntaxFactory.UsingDirective(
                     SyntaxFactory.ParseName(interfaceNamespace));
 
-                // Check if using already exists
                 var existingUsings = newRoot.Usings
                     .Select(u => u.Name.ToString())
                     .ToList();
@@ -412,9 +785,34 @@ public static string AppendInterfaceToClass(string sourceCode, string className,
                 }
             }
 
-            // Add NormalizeWhitespace() to properly format the output
             return newRoot.NormalizeWhitespace().ToFullString();
         }
+
+        private static int GetMemberTypeOrder(MemberType type)
+        {
+            switch (type)
+            {
+                case MemberType.Property: return 1;
+                case MemberType.Method: return 2;
+                case MemberType.Event: return 3;
+                case MemberType.Indexer: return 4;
+                case MemberType.Operator: return 5;
+                default: return 99;
+            }
+        }
+
+        private static string GetMemberTypeGroupName(MemberType type)
+        {
+            switch (type)
+            {
+                case MemberType.Property: return "Properties";
+                case MemberType.Method: return "Methods";
+                case MemberType.Event: return "Events";
+                case MemberType.Indexer: return "Indexers";
+                case MemberType.Operator: return "Operators";
+                default: return "Members";
+            }
+        }
     }
 
     public class ExtractedClassInfo
@@ -424,6 +822,8 @@ public class ExtractedClassInfo
         public List<MemberInfo> Members { get; set; }
         public List<string> Usings { get; set; }
         public string FilePath { get; set; }
+        public bool IsPartial { get; set; }
+        public bool IsRecord { get; set; }
     }
 
     public class MemberInfo
@@ -441,6 +841,7 @@ public enum MemberType
         Method,
         Property,
         Event,
-        Indexer
+        Indexer,
+        Operator
     }
 }
\ No newline at end of file
diff --git a/InterfaceExtractor.Extension/UI/ExtractInterfaceDialog.xaml.cs b/InterfaceExtractor.Extension/UI/ExtractInterfaceDialog.xaml.cs
index ff6a55f..adc62a5 100644
--- a/InterfaceExtractor.Extension/UI/ExtractInterfaceDialog.xaml.cs
+++ b/InterfaceExtractor.Extension/UI/ExtractInterfaceDialog.xaml.cs
@@ -1,4 +1,5 @@
 using Microsoft.CodeAnalysis.CSharp;
+using InterfaceExtractor.Options;
 using System.Collections.Generic;
 using System.Linq;
 using System.Windows;
@@ -7,15 +8,19 @@ namespace InterfaceExtractor.UI
 {
     public partial class ExtractInterfaceDialog : Window
     {
+        private readonly ExtractorOptions options;
+
         public string InterfaceName { get; private set; }
         public List<MemberSelectionItem> Members { get; private set; }
 
-        public ExtractInterfaceDialog(string className, List<MemberSelectionItem> members)
+        public ExtractInterfaceDialog(string className, List<MemberSelectionItem> members, ExtractorOptions options = null)
         {
             InitializeComponent();
 
+            this.options = options ?? new ExtractorOptions();
+
             ClassNameText.Text = className;
-            InterfaceNameTextBox.Text = $"{Constants.InterfacePrefix}{className}";
+            InterfaceNameTextBox.Text = $"{this.options.InterfacePrefix}{className}";
             Members = members;
 
             MembersListBox.ItemsSource = Members;
@@ -26,10 +31,9 @@ public ExtractInterfaceDialog(string className, List<MemberSelectionItem> member
                 member.IsSelected = true;
             }
 
-            // Update select all checkbox state
             UpdateSelectAllCheckBox();
 
-            // Subscribe to property changes to update select all checkbox
+            // Subscribe to property changes
             foreach (var member in Members)
             {
                 member.PropertyChanged += (s, e) =>
@@ -59,7 +63,7 @@ private void UpdateSelectAllCheckBox()
             }
             else
             {
-                SelectAllCheckBox.IsChecked = null; // Indeterminate state
+                SelectAllCheckBox.IsChecked = null;
             }
         }
 
@@ -106,11 +110,13 @@ private void OK_Click(object sender, RoutedEventArgs e)
                 return;
             }
 
-            // Warn if doesn't start with 'I'
-            if (!InterfaceName.StartsWith(Constants.InterfacePrefix) || InterfaceName.Length < 2)
+            // Warn if doesn't start with prefix (respecting options)
+            if (options.WarnIfNoIPrefix &&
+                !string.IsNullOrEmpty(options.InterfacePrefix) &&
+                (!InterfaceName.StartsWith(options.InterfacePrefix) || InterfaceName.Length < options.InterfacePrefix.Length + 1))
             {
                 var result = MessageBox.Show(
-                    $"Interface names typically start with '{Constants.InterfacePrefix}'. Do you want to continue?",
+                    $"Interface names typically start with '{options.InterfacePrefix}'. Do you want to continue?",
                     Constants.ExtensionName,
                     MessageBoxButton.YesNo,
                     MessageBoxImage.Question);
@@ -162,7 +168,6 @@ private void DeselectAll_Click(object sender, RoutedEventArgs e)
 
         private void SelectAllCheckBox_Changed(object sender, RoutedEventArgs e)
         {
-            // Prevent recursion
             if (SelectAllCheckBox.IsChecked == null)
                 return;
 
diff --git a/InterfaceExtractor.Extension/UI/OverwriteDialog.xaml b/InterfaceExtractor.Extension/UI/OverwriteDialog.xaml
index e7b370a..53d1457 100644
--- a/InterfaceExtractor.Extension/UI/OverwriteDialog.xaml
+++ b/InterfaceExtractor.Extension/UI/OverwriteDialog.xaml
@@ -2,7 +2,7 @@
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         Title="File Exists"
-        Height="220" Width="450"
+        Height="240" Width="450"
         WindowStartupLocation="CenterOwner"
         ResizeMode="NoResize"
         ShowInTaskbar="False"
diff --git a/InterfaceExtractor.Extension/UI/PreviewDialog.xaml b/InterfaceExtractor.Extension/UI/PreviewDialog.xaml
new file mode 100644
index 0000000..ac04832
--- /dev/null
+++ b/InterfaceExtractor.Extension/UI/PreviewDialog.xaml
@@ -0,0 +1,88 @@
+<Window x:Class="InterfaceExtractor.UI.PreviewDialog"
+        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+        xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
+        xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
+        mc:Ignorable="d"
+        Title="Interface Preview"
+        Height="600" Width="800"
+        WindowStartupLocation="CenterOwner"
+        ResizeMode="CanResize"
+        ShowInTaskbar="False">
+    <Window.Resources>
+        <Style TargetType="Button">
+            <Setter Property="Padding" Value="20,8" />
+            <Setter Property="Margin" Value="5,0" />
+            <Setter Property="MinWidth" Value="100" />
+        </Style>
+    </Window.Resources>
+
+    <Grid Margin="15">
+        <Grid.RowDefinitions>
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="Auto" />
+            <RowDefinition Height="*" />
+            <RowDefinition Height="Auto" />
+        </Grid.RowDefinitions>
+
+        <!-- Header -->
+        <TextBlock Grid.Row="0"
+                   Text="Preview the generated interface before saving"
+                   FontWeight="Bold"
+                   FontSize="14"
+                   Margin="0,0,0,10" />
+
+        <!-- File Info -->
+        <Grid Grid.Row="1" Margin="0,0,0,10">
+            <Grid.ColumnDefinitions>
+                <ColumnDefinition Width="Auto" />
+                <ColumnDefinition Width="*" />
+            </Grid.ColumnDefinitions>
+            <Grid.RowDefinitions>
+                <RowDefinition Height="Auto" />
+                <RowDefinition Height="Auto" />
+            </Grid.RowDefinitions>
+
+            <TextBlock Grid.Row="0" Grid.Column="0" Text="Interface: " FontWeight="SemiBold" Margin="0,0,10,5" />
+            <TextBlock Grid.Row="0" Grid.Column="1" x:Name="InterfaceNameText" Margin="0,0,0,5" />
+
+            <TextBlock Grid.Row="1" Grid.Column="0" Text="File: " FontWeight="SemiBold" Margin="0,0,10,0" />
+            <TextBlock Grid.Row="1" Grid.Column="1" x:Name="FilePathText" />
+        </Grid>
+
+        <!-- Code Preview -->
+        <Border Grid.Row="2"
+                BorderBrush="#CCCCCC"
+                BorderThickness="1"
+                Background="#F8F8F8"
+                Margin="0,0,0,15">
+            <ScrollViewer VerticalScrollBarVisibility="Auto"
+                         HorizontalScrollBarVisibility="Auto">
+                <TextBox x:Name="PreviewTextBox"
+                        IsReadOnly="True"
+                        FontFamily="Consolas"
+                        FontSize="12"
+                        TextWrapping="NoWrap"
+                        BorderThickness="0"
+                        Background="Transparent"
+                        Padding="10"
+                        VerticalScrollBarVisibility="Auto"
+                        HorizontalScrollBarVisibility="Auto" />
+            </ScrollViewer>
+        </Border>
+
+        <!-- Buttons -->
+        <StackPanel Grid.Row="3"
+                   Orientation="Horizontal"
+                   HorizontalAlignment="Right">
+            <Button Content="Save"
+                   IsDefault="True"
+                   Click="Save_Click"
+                   ToolTip="Save the interface to disk" />
+            <Button Content="Cancel"
+                   IsCancel="True"
+                   Click="Cancel_Click"
+                   ToolTip="Cancel without saving" />
+        </StackPanel>
+    </Grid>
+</Window>
\ No newline at end of file
diff --git a/InterfaceExtractor.Extension/UI/PreviewDialog.xaml.cs b/InterfaceExtractor.Extension/UI/PreviewDialog.xaml.cs
new file mode 100644
index 0000000..5eba0a0
--- /dev/null
+++ b/InterfaceExtractor.Extension/UI/PreviewDialog.xaml.cs
@@ -0,0 +1,34 @@
+using System.Windows;
+
+namespace InterfaceExtractor.UI
+{
+    public partial class PreviewDialog : Window
+    {
+        public bool UserApproved { get; private set; }
+
+        public PreviewDialog(string interfaceName, string filePath, string interfaceCode)
+        {
+            InitializeComponent();
+
+            InterfaceNameText.Text = interfaceName;
+            FilePathText.Text = filePath;
+            PreviewTextBox.Text = interfaceCode;
+
+            UserApproved = false;
+        }
+
+        private void Save_Click(object sender, RoutedEventArgs e)
+        {
+            UserApproved = true;
+            DialogResult = true;
+            Close();
+        }
+
+        private void Cancel_Click(object sender, RoutedEventArgs e)
+        {
+            UserApproved = false;
+            DialogResult = false;
+            Close();
+        }
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Extension/source.extension.vsixmanifest b/InterfaceExtractor.Extension/source.extension.vsixmanifest
index 4fc9c87..1bde815 100644
--- a/InterfaceExtractor.Extension/source.extension.vsixmanifest
+++ b/InterfaceExtractor.Extension/source.extension.vsixmanifest
@@ -1,29 +1,29 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <PackageManifest Version="2.0.0" xmlns="http://schemas.microsoft.com/developer/vsx-schema/2011" xmlns:d="http://schemas.microsoft.com/developer/vsx-schema-design/2011">
-	<Metadata>
-		<Identity Id="InterfaceExtractor.6fa7b9f2-c586-4bd2-8735-939937fa55d6" Version="1.0" Language="en-US" Publisher="Developer Chizaruu" />
-		<DisplayName>Interface Extractor</DisplayName>
-		<Description xml:space="preserve">Extract interfaces from C# files directly from Solution Explorer. Right-click any C# file to automatically generate interface files with all public methods and properties.</Description>
-		<Tags>interface, extract, refactor, C#, productivity</Tags>
-	</Metadata>
-	<Installation>
-		<InstallationTarget Id="Microsoft.VisualStudio.Community" Version="[17.0, 18.0)">
-			<ProductArchitecture>amd64</ProductArchitecture>
-		</InstallationTarget>
-		<InstallationTarget Id="Microsoft.VisualStudio.Pro" Version="[17.0, 18.0)">
-			<ProductArchitecture>amd64</ProductArchitecture>
-		</InstallationTarget>
-		<InstallationTarget Id="Microsoft.VisualStudio.Enterprise" Version="[17.0, 18.0)">
-			<ProductArchitecture>amd64</ProductArchitecture>
-		</InstallationTarget>
-	</Installation>
-	<Dependencies>
-		<Dependency Id="Microsoft.Framework.NDP" DisplayName="Microsoft .NET Framework" d:Source="Manual" Version="[4.5,)" />
-	</Dependencies>
-	<Prerequisites>
-		<Prerequisite Id="Microsoft.VisualStudio.Component.CoreEditor" Version="[17.0,18.0)" DisplayName="Visual Studio core editor" />
-	</Prerequisites>
-	<Assets>
-		<Asset Type="Microsoft.VisualStudio.VsPackage" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%;PkgdefProjectOutputGroup|" />
-	</Assets>
+  <Metadata>
+    <Identity Id="InterfaceExtractor.6fa7b9f2-c586-4bd2-8735-939937fa55d6" Version="1.2.1.0" Language="en-US" Publisher="Chizaruu" />
+    <DisplayName>Interface Extractor</DisplayName>
+    <Description xml:space="preserve">Extract interfaces from C# files directly from Solution Explorer. Right-click any C# file to automatically generate interface files with all public methods and properties.</Description>
+    <Tags>interface, extract, refactor, C#, productivity</Tags>
+  </Metadata>
+  <Installation>
+    <InstallationTarget Id="Microsoft.VisualStudio.Community" Version="[17.0, 18.0)">
+      <ProductArchitecture>amd64</ProductArchitecture>
+    </InstallationTarget>
+    <InstallationTarget Id="Microsoft.VisualStudio.Pro" Version="[17.0, 18.0)">
+      <ProductArchitecture>amd64</ProductArchitecture>
+    </InstallationTarget>
+    <InstallationTarget Id="Microsoft.VisualStudio.Enterprise" Version="[17.0, 18.0)">
+      <ProductArchitecture>amd64</ProductArchitecture>
+    </InstallationTarget>
+  </Installation>
+  <Dependencies>
+    <Dependency Id="Microsoft.Framework.NDP" DisplayName="Microsoft .NET Framework" d:Source="Manual" Version="[4.5,)" />
+  </Dependencies>
+  <Prerequisites>
+    <Prerequisite Id="Microsoft.VisualStudio.Component.CoreEditor" Version="[17.0,18.0)" DisplayName="Visual Studio core editor" />
+  </Prerequisites>
+  <Assets>
+    <Asset Type="Microsoft.VisualStudio.VsPackage" d:Source="Project" d:ProjectName="%CurrentProject%" Path="|%CurrentProject%;PkgdefProjectOutputGroup|" />
+  </Assets>
 </PackageManifest>
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/Helpers/TestHelpers.cs b/InterfaceExtractor.Tests/Helpers/TestHelpers.cs
index e3349f4..b2be1ab 100644
--- a/InterfaceExtractor.Tests/Helpers/TestHelpers.cs
+++ b/InterfaceExtractor.Tests/Helpers/TestHelpers.cs
@@ -285,6 +285,95 @@ public class NestedClass
         }
     }
 }";
+
+            // v1.2.0: Record types
+            public static string SimpleRecord => @"
+namespace TestNamespace
+{
+    public record Person
+    {
+        public string FirstName { get; init; }
+        public string LastName { get; init; }
+        public int Age { get; init; }
+    }
+}";
+
+            public static string PrimaryConstructorRecord => @"
+namespace TestNamespace
+{
+    public record Person(string FirstName, string LastName, int Age);
+}";
+
+            public static string RecordWithMethods => @"
+using System;
+
+namespace TestNamespace
+{
+    public record Person
+    {
+        public string FirstName { get; init; }
+        public string LastName { get; init; }
+        public DateTime BirthDate { get; init; }
+
+        public int GetAge() => (DateTime.Now - BirthDate).Days / 365;
+        public string GetFullName() => $""{FirstName} {LastName}"";
+    }
+}";
+
+            // v1.2.0: Partial classes
+            public static string PartialClassPart1 => @"
+namespace TestNamespace
+{
+    public partial class UserService
+    {
+        public void GetUser(int id) { }
+        public void UpdateUser(User user) { }
+    }
+
+    public class User
+    {
+        public int Id { get; set; }
+        public string Name { get; set; }
+    }
+}";
+
+            public static string PartialClassPart2 => @"
+namespace TestNamespace
+{
+    public partial class UserService
+    {
+        public void DeleteUser(int id) { }
+        public void ListUsers() { }
+    }
+}";
+
+            // v1.2.0: Internal members
+            public static string ClassWithInternalMembers => @"
+using System;
+
+namespace TestNamespace
+{
+    public class ApiService
+    {
+        public void PublicApi() { }
+        internal void InternalApi() { }
+        private void PrivateApi() { }
+
+        public string PublicProperty { get; set; }
+        internal string InternalProperty { get; set; }
+        private string PrivateProperty { get; set; }
+    }
+}";
+
+            public static string InternalClass => @"
+namespace TestNamespace
+{
+    internal class InternalDataService
+    {
+        public void ProcessData() { }
+        public string Data { get; set; }
+    }
+}";
         }
 
         /// <summary>
diff --git a/InterfaceExtractor.Tests/Integration/IntegrationTests.cs b/InterfaceExtractor.Tests/Integration/IntegrationTests.cs
index d0b8f0d..6fb97bf 100644
--- a/InterfaceExtractor.Tests/Integration/IntegrationTests.cs
+++ b/InterfaceExtractor.Tests/Integration/IntegrationTests.cs
@@ -11,6 +11,7 @@ namespace InterfaceExtractor.Tests.Integration
 {
     /// <summary>
     /// Integration tests that test the complete flow from analysis to interface generation
+    /// Updated for v1.2.0
     /// </summary>
     public class IntegrationTests : IDisposable
     {
@@ -69,7 +70,7 @@ public async Task CompleteFlow_SimpleClass_GeneratesCorrectInterfaceAsync()
             classInfos[0].Members.Should().HaveCount(3); // Name, Age, DoSomething
 
             // Act - Generate
-            var interfaceCode = InterfaceExtractorService.GenerateInterface(
+            var interfaceCode = _service.GenerateInterface(
                 "ISimpleClass",
                 classInfos[0],
                 classInfos[0].Members);
@@ -92,7 +93,7 @@ public async Task CompleteFlow_ClassWithDocumentation_PreservesDocumentationAsyn
 
             // Act
             var classInfos = await _service.AnalyzeClassesAsync(filePath);
-            var interfaceCode = InterfaceExtractorService.GenerateInterface(
+            var interfaceCode = _service.GenerateInterface(
                 "IDocumentedClass",
                 classInfos[0],
                 classInfos[0].Members);
@@ -115,7 +116,7 @@ public async Task CompleteFlow_GenericClass_HandlesConstraintsAsync()
 
             // Act
             var classInfos = await _service.AnalyzeClassesAsync(filePath);
-            var interfaceCode = InterfaceExtractorService.GenerateInterface(
+            var interfaceCode = _service.GenerateInterface(
                 "IGenericRepository",
                 classInfos[0],
                 classInfos[0].Members);
@@ -209,15 +210,15 @@ public void CompleteFlow_AppendInterface_UpdatesClassAsync()
             // Arrange
             var sourceCode = TestHelpers.SampleCode.SimpleClass;
 
-            // Act - Append interface to class
-            var updatedCode = InterfaceExtractorService.AppendInterfaceToClass(
+            // Act
+            var updatedCode = _service.AppendInterfaceToClass(
                 sourceCode,
                 "SimpleClass",
                 "ISimpleClass",
                 "TestNamespace.Interfaces");
 
             // Assert
-            updatedCode.Should().Contain("public class SimpleClass : TestNamespace.Interfaces.ISimpleClass");
+            updatedCode.Should().Contain("public class SimpleClass : ISimpleClass");
             updatedCode.Should().Contain("using TestNamespace.Interfaces;");
         }
 
@@ -237,7 +238,7 @@ public async Task CompleteFlow_SelectiveMembers_GeneratesPartialInterfaceAsync()
                 .Where(m => m.Name == "Name")
                 .ToList();
 
-            var interfaceCode = InterfaceExtractorService.GenerateInterface(
+            var interfaceCode = _service.GenerateInterface(
                 "ISimpleClass",
                 classInfos[0],
                 selectedMembers);
@@ -305,7 +306,7 @@ public async Task CompleteFlow_SaveToFile_CreatesValidCSharpFileAsync()
 
             // Act
             var classInfos = await _service.AnalyzeClassesAsync(filePath);
-            var interfaceCode = InterfaceExtractorService.GenerateInterface(
+            var interfaceCode = _service.GenerateInterface(
                 "ISimpleClass",
                 classInfos[0],
                 classInfos[0].Members);
@@ -324,5 +325,121 @@ public async Task CompleteFlow_SaveToFile_CreatesValidCSharpFileAsync()
 
             diagnostics.Should().NotContain(d => d.Severity == Microsoft.CodeAnalysis.DiagnosticSeverity.Error);
         }
+
+        // v1.2.0: Record type tests
+        [Fact]
+        public async Task CompleteFlow_SimpleRecord_GeneratesCorrectInterfaceAsync()
+        {
+            // Arrange
+            var filePath = TestHelpers.CreateTempCSharpFile(
+                TestHelpers.SampleCode.SimpleRecord,
+                _tempDirectory);
+
+            // Act
+            var classInfos = await _service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            classInfos.Should().HaveCount(1);
+            classInfos[0].ClassName.Should().Be("Person");
+            classInfos[0].IsRecord.Should().BeTrue();
+            classInfos[0].Members.Should().HaveCount(3); // FirstName, LastName, Age
+        }
+
+        [Fact]
+        public async Task CompleteFlow_RecordWithMethods_ExtractsAllMembersAsync()
+        {
+            // Arrange
+            var filePath = TestHelpers.CreateTempCSharpFile(
+                TestHelpers.SampleCode.RecordWithMethods,
+                _tempDirectory);
+
+            // Act
+            var classInfos = await _service.AnalyzeClassesAsync(filePath);
+            var interfaceCode = _service.GenerateInterface(
+                "IPerson",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            classInfos[0].IsRecord.Should().BeTrue();
+            interfaceCode.Should().Contain("public interface IPerson");
+            // init accessors are converted to get-only in interfaces (init not valid in interfaces)
+            interfaceCode.Should().Contain("string FirstName { get; }");
+            interfaceCode.Should().Contain("string LastName { get; }");
+            interfaceCode.Should().Contain("DateTime BirthDate { get; }");
+            interfaceCode.Should().Contain("int GetAge();");
+            interfaceCode.Should().Contain("string GetFullName();");
+        }
+
+        // v1.2.0: Internal member tests
+        [Fact]
+        public async Task CompleteFlow_InternalMembers_ExcludedByDefaultAsync()
+        {
+            // Arrange
+            var filePath = TestHelpers.CreateTempCSharpFile(
+                TestHelpers.SampleCode.ClassWithInternalMembers,
+                _tempDirectory);
+
+            // Act
+            var classInfos = await _service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            var members = classInfos[0].Members;
+            members.Should().Contain(m => m.Name == "PublicApi");
+            members.Should().Contain(m => m.Name == "PublicProperty");
+            members.Should().NotContain(m => m.Name == "InternalApi");
+            members.Should().NotContain(m => m.Name == "InternalProperty");
+        }
+
+        [Fact]
+        public async Task CompleteFlow_InternalClass_ExcludedByDefaultAsync()
+        {
+            // Arrange
+            var filePath = TestHelpers.CreateTempCSharpFile(
+                TestHelpers.SampleCode.InternalClass,
+                _tempDirectory);
+
+            // Act
+            var classInfos = await _service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            classInfos.Should().BeEmpty();
+        }
+
+        // v1.2.0: Implementation stub tests
+        [Fact]
+        public async Task CompleteFlow_GenerateImplementationStub_CreatesValidClassAsync()
+        {
+            // Arrange
+            var options = new Options.ExtractorOptions
+            {
+                GenerateImplementationStubs = true,
+                ImplementationStubSuffix = "Implementation"
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var filePath = TestHelpers.CreateTempCSharpFile(
+                TestHelpers.SampleCode.SimpleClass,
+                _tempDirectory);
+
+            // Act
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+            var stubCode = service.GenerateImplementationStub(
+                "ISimpleClass",
+                "SimpleClassImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("public class SimpleClassImplementation : ISimpleClass");
+            stubCode.Should().Contain("public string Name { get; set; }");
+            stubCode.Should().Contain("public int Age { get; set; }");
+            stubCode.Should().Contain("public void DoSomething()");
+
+            // Verify it compiles
+            var tree = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(stubCode);
+            var diagnostics = tree.GetDiagnostics();
+            diagnostics.Should().NotContain(d => d.Severity == Microsoft.CodeAnalysis.DiagnosticSeverity.Error);
+        }
     }
 }
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/Services/ImplementationStubTests.cs b/InterfaceExtractor.Tests/Services/ImplementationStubTests.cs
new file mode 100644
index 0000000..afb7ed2
--- /dev/null
+++ b/InterfaceExtractor.Tests/Services/ImplementationStubTests.cs
@@ -0,0 +1,476 @@
+using FluentAssertions;
+using InterfaceExtractor.Options;
+using InterfaceExtractor.Services;
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace InterfaceExtractor.Tests.Services
+{
+    /// <summary>
+    /// Tests for implementation stub generation (v1.2.0)
+    /// </summary>
+    public class ImplementationStubTests : IDisposable
+    {
+        private readonly string _tempDirectory;
+        private bool _disposed;
+
+        public ImplementationStubTests()
+        {
+            _tempDirectory = Path.Combine(Path.GetTempPath(), $"StubTests_{Guid.NewGuid()}");
+            Directory.CreateDirectory(_tempDirectory);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing && Directory.Exists(_tempDirectory))
+                {
+                    try { Directory.Delete(_tempDirectory, true); }
+                    catch { /* Ignore cleanup errors */ }
+                }
+                _disposed = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_WithMethods_ThrowsNotImplementedException()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+namespace Test
+{
+    public class UserService
+    {
+        public string GetUser(int id) { return null; }
+        public void SaveUser(string name) { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "IUserService",
+                "UserServiceImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("public class UserServiceImplementation : IUserService");
+            stubCode.Should().Contain("public string GetUser(int id)");
+            stubCode.Should().Contain("throw new System.NotImplementedException();");
+            stubCode.Should().Contain("public void SaveUser(string name)");
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_WithProperties_GeneratesAutoProperties()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+namespace Test
+{
+    public class Person
+    {
+        public string Name { get; set; }
+        public int Age { get; }
+        public string Email { get; set; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "IPerson",
+                "PersonImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("public class PersonImplementation : IPerson");
+            stubCode.Should().Contain("public string Name { get; set; }");
+            stubCode.Should().Contain("public int Age { get; }");
+            stubCode.Should().Contain("public string Email { get; set; }");
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_WithEvents_GeneratesEventFields()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+using System;
+
+namespace Test
+{
+    public class EventSource
+    {
+        public event EventHandler Started;
+        public event EventHandler<DataEventArgs> DataReceived;
+    }
+
+    public class DataEventArgs : EventArgs { }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "IEventSource",
+                "EventSourceImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("public class EventSourceImplementation : IEventSource");
+            stubCode.Should().Contain("public event EventHandler Started;");
+            stubCode.Should().Contain("public event EventHandler<DataEventArgs> DataReceived;");
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_WithIndexers_GeneratesIndexerStubs()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+namespace Test
+{
+    public class DataStore
+    {
+        public string this[int index] { get { return null; } set { } }
+        public string this[string key] { get { return null; } }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "IDataStore",
+                "DataStoreImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("public class DataStoreImplementation : IDataStore");
+            // Stubs generate simplified indexer syntax
+            stubCode.Should().Contain("public string this[int index] { get; set; }");
+            stubCode.Should().Contain("public string this[string key] { get; }");
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_WithTaskReturnType_ReturnsCompletedTask()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+using System.Threading.Tasks;
+
+namespace Test
+{
+    public class AsyncService
+    {
+        public async Task ProcessAsync() { }
+        public async Task<string> GetDataAsync() { return null; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "IAsyncService",
+                "AsyncServiceImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("public Task ProcessAsync()");
+            stubCode.Should().Contain("return Task.CompletedTask;");
+            stubCode.Should().Contain("public Task<string> GetDataAsync()");
+            stubCode.Should().Contain("throw new System.NotImplementedException();");
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_WithDocumentation_PreservesDocumentation()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+namespace Test
+{
+    public class Calculator
+    {
+        /// <summary>
+        /// Adds two numbers
+        /// </summary>
+        /// <param name=""a"">First number</param>
+        /// <param name=""b"">Second number</param>
+        /// <returns>The sum</returns>
+        public int Add(int a, int b) { return 0; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "ICalculator",
+                "CalculatorImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("/// <summary>");
+            stubCode.Should().Contain("/// Adds two numbers");
+            stubCode.Should().Contain("/// <param name=\"a\">First number</param>");
+            stubCode.Should().Contain("/// <returns>The sum</returns>");
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_WithGenericConstraints_IncludesConstraints()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+namespace Test
+{
+    public class Repository
+    {
+        public T GetById<T>(int id) where T : class, new() { return null; }
+        public void Save<T>(T entity) where T : class, IEntity { }
+    }
+
+    public interface IEntity { }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "IRepository",
+                "RepositoryImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("public T GetById<T>(int id)");
+            stubCode.Should().Contain("where T : class, new()");
+            stubCode.Should().Contain("public void Save<T>(T entity)");
+            stubCode.Should().Contain("where T : class, IEntity");
+        }
+
+        [Fact]
+        public void GenerateImplementationStub_WithCustomSuffix_UsesCustomSuffix()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                ImplementationStubSuffix = "Service"
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var classInfo = new ExtractedClassInfo
+            {
+                ClassName = "User",
+                Namespace = "Test",
+                Usings = [],
+                Members =
+                [
+                    new MemberInfo
+                    {
+                        Type = MemberType.Property,
+                        Signature = "string Name { get; set; }",
+                        Name = "Name"
+                    }
+                ]
+            };
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "IUser",
+                "UserService",
+                classInfo,
+                classInfo.Members);
+
+            // Assert
+            stubCode.Should().Contain("public class UserService : IUser");
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_AddsUsingForInterfaceNamespace()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+using System;
+
+namespace Test.Data
+{
+    public class Repository
+    {
+        public void Save() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "IRepository",
+                "RepositoryImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("using Test.Data.Interfaces;");
+            stubCode.Should().Contain("namespace Test.Data");
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_WithFileHeader_IncludesHeader()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                IncludeFileHeader = true,
+                FileHeaderTemplate = "// Auto-generated stub\n// Date: {Date}"
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class Service
+    {
+        public void Execute() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "IService",
+                "ServiceImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().StartWith("// Auto-generated stub");
+            stubCode.Should().Contain($"// Date: {DateTime.Now:yyyy-MM-dd}");
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_CompilesSuccessfully()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+using System;
+using System.Threading.Tasks;
+
+namespace Test
+{
+    public class CompleteService
+    {
+        public string Name { get; set; }
+        public int Count { get; }
+
+        public void DoSomething() { }
+        public string GetValue() { return null; }
+        public async Task ProcessAsync() { }
+        public async Task<int> CalculateAsync() { return 0; }
+
+        public event EventHandler Changed;
+
+        public string this[int index] { get { return null; } set { } }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "ICompleteService",
+                "CompleteServiceImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert - Can be parsed as valid C#
+            var tree = Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree.ParseText(stubCode);
+            var diagnostics = tree.GetDiagnostics();
+            diagnostics.Should().NotContain(d => d.Severity == Microsoft.CodeAnalysis.DiagnosticSeverity.Error);
+        }
+
+        [Fact]
+        public async Task GenerateImplementationStub_WithVoidMethod_HasEmptyBody()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+namespace Test
+{
+    public class Logger
+    {
+        public void Log(string message) { }
+        public void LogError(string message) { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var stubCode = service.GenerateImplementationStub(
+                "ILogger",
+                "LoggerImplementation",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            stubCode.Should().Contain("public class LoggerImplementation : ILogger");
+            stubCode.Should().Contain("public void Log(string message)");
+            stubCode.Should().Contain("public void LogError(string message)");
+
+            // Void methods should have empty body (no return, no throw)
+            // Check that the method body exists but is empty
+            var lines = stubCode.Split('\n');
+            var logMethodLine = Array.FindIndex(lines, l => l.Contains("public void Log(string message)"));
+            logMethodLine.Should().BeGreaterThan(0);
+
+            // The next line should be opening brace, followed by closing brace
+            lines[logMethodLine + 1].Trim().Should().Be("{");
+            lines[logMethodLine + 2].Trim().Should().Be("}");
+        }
+
+        private string CreateTempFile(string content)
+        {
+            var fileName = $"Test_{Guid.NewGuid()}.cs";
+            var filePath = Path.Combine(_tempDirectory, fileName);
+            File.WriteAllText(filePath, content);
+            return filePath;
+        }
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/Services/InterfaceExtractorServiceTests.cs b/InterfaceExtractor.Tests/Services/InterfaceExtractorServiceTests.cs
index eba75e6..214616b 100644
--- a/InterfaceExtractor.Tests/Services/InterfaceExtractorServiceTests.cs
+++ b/InterfaceExtractor.Tests/Services/InterfaceExtractorServiceTests.cs
@@ -396,8 +396,8 @@ public void GenerateInterface_WithBasicClass_GeneratesCorrectInterface()
                 ]
             };
 
-            // Act
-            var result = InterfaceExtractorService.GenerateInterface(
+            // Act - using instance method
+            var result = _service.GenerateInterface(
                 "ITestClass",
                 classInfo,
                 classInfo.Members);
@@ -432,7 +432,7 @@ public void GenerateInterface_WithXmlDocumentation_IncludesDocumentation()
             };
 
             // Act
-            var result = InterfaceExtractorService.GenerateInterface(
+            var result = _service.GenerateInterface(
                 "ITestClass",
                 classInfo,
                 classInfo.Members);
@@ -465,7 +465,7 @@ public void GenerateInterface_WithGenericConstraints_FormatsConstraintsCorrectly
             };
 
             // Act
-            var result = InterfaceExtractorService.GenerateInterface(
+            var result = _service.GenerateInterface(
                 "ITestClass",
                 classInfo,
                 classInfo.Members);
@@ -487,17 +487,17 @@ public void GenerateInterface_WithMultipleMembers_SeparatesWithBlankLines()
                 Members =
                 [
                     new MemberInfo { Type = MemberType.Property, Signature = "string First { get; set; }", Name = "First" },
-            new MemberInfo { Type = MemberType.Property, Signature = "string Second { get; set; }", Name = "Second" }
+                    new MemberInfo { Type = MemberType.Property, Signature = "string Second { get; set; }", Name = "Second" }
                 ]
             };
 
             // Act
-            var result = InterfaceExtractorService.GenerateInterface(
+            var result = _service.GenerateInterface(
                 "ITestClass",
                 classInfo,
                 classInfo.Members);
 
-            var lines = result.Split(new[] { '\r', '\n' }, StringSplitOptions.None);
+            var lines = result.Split(['\r', '\n'], StringSplitOptions.None);
             var firstIndex = Array.FindIndex(lines, l => l.Contains("string First"));
             var secondIndex = Array.FindIndex(lines, l => l.Contains("string Second"));
 
@@ -527,15 +527,16 @@ public class TestClass
     }
 }";
 
-            // Act
-            var result = InterfaceExtractorService.AppendInterfaceToClass(
+            // Act - using instance method
+            var result = _service.AppendInterfaceToClass(
                 sourceCode,
                 "TestClass",
                 "ITestClass",
                 "TestNamespace.Interfaces");
 
-            // Assert
-            result.Should().Contain("public class TestClass : TestNamespace.Interfaces.ITestClass");
+            // Assert - Default options have AddUsingDirective=true, so uses simple name
+            result.Should().Contain("public class TestClass : ITestClass");
+            result.Should().Contain("using TestNamespace.Interfaces;");
         }
 
         [Fact]
@@ -552,14 +553,15 @@ public class TestClass : BaseClass
 }";
 
             // Act
-            var result = InterfaceExtractorService.AppendInterfaceToClass(
+            var result = _service.AppendInterfaceToClass(
                 sourceCode,
                 "TestClass",
                 "ITestClass",
                 "TestNamespace.Interfaces");
 
-            // Assert
-            result.Should().Contain("public class TestClass : BaseClass, TestNamespace.Interfaces.ITestClass");
+            // Assert - Default options have AddUsingDirective=true, so uses simple name
+            result.Should().Contain("public class TestClass : BaseClass, ITestClass");
+            result.Should().Contain("using TestNamespace.Interfaces;");
         }
 
         [Fact]
@@ -576,7 +578,7 @@ public class TestClass : ITestClass
 }";
 
             // Act
-            var result = InterfaceExtractorService.AppendInterfaceToClass(
+            var result = _service.AppendInterfaceToClass(
                 sourceCode,
                 "TestClass",
                 "ITestClass",
@@ -600,7 +602,7 @@ public class TestClass
 }";
 
             // Act
-            var result = InterfaceExtractorService.AppendInterfaceToClass(
+            var result = _service.AppendInterfaceToClass(
                 sourceCode,
                 "TestClass",
                 "ITestClass",
@@ -627,7 +629,7 @@ public class TestClass
 }";
 
             // Act
-            var result = InterfaceExtractorService.AppendInterfaceToClass(
+            var result = _service.AppendInterfaceToClass(
                 sourceCode,
                 "TestClass",
                 "ITestClass",
@@ -637,6 +639,32 @@ public class TestClass
             result.Should().Contain("using TestNamespace.Interfaces;");
         }
 
+        [Fact]
+        public void AppendInterfaceToClass_WithAddUsingDirective_UsesSimpleName()
+        {
+            // Arrange
+            var sourceCode = @"
+namespace TestNamespace
+{
+    public class TestClass
+    {
+        public string Name { get; set; }
+    }
+}";
+
+            // Act
+            var result = _service.AppendInterfaceToClass(
+                sourceCode,
+                "TestClass",
+                "ITestClass",
+                "TestNamespace.Interfaces");
+
+            // Assert - Should use simple name since using directive is added
+            result.Should().Contain("public class TestClass : ITestClass");
+            result.Should().NotContain("TestNamespace.Interfaces.ITestClass");
+            result.Should().Contain("using TestNamespace.Interfaces;");
+        }
+
         [Fact]
         public void AppendInterfaceToClass_DoesNotAddDuplicateUsing()
         {
@@ -654,7 +682,7 @@ public class TestClass
 }";
 
             // Act
-            var result = InterfaceExtractorService.AppendInterfaceToClass(
+            var result = _service.AppendInterfaceToClass(
                 sourceCode,
                 "TestClass",
                 "ITestClass",
@@ -679,7 +707,7 @@ public class OtherClass
 }";
 
             // Act
-            var result = InterfaceExtractorService.AppendInterfaceToClass(
+            var result = _service.AppendInterfaceToClass(
                 sourceCode,
                 "TestClass",
                 "ITestClass",
diff --git a/InterfaceExtractor.Tests/Services/InternalMemberTests.cs b/InterfaceExtractor.Tests/Services/InternalMemberTests.cs
new file mode 100644
index 0000000..9e2ce2f
--- /dev/null
+++ b/InterfaceExtractor.Tests/Services/InternalMemberTests.cs
@@ -0,0 +1,390 @@
+using FluentAssertions;
+using InterfaceExtractor.Options;
+using InterfaceExtractor.Services;
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace InterfaceExtractor.Tests.Services
+{
+    /// <summary>
+    /// Tests for internal member support (v1.2.0)
+    /// </summary>
+    public class InternalMemberTests : IDisposable
+    {
+        private readonly string _tempDirectory;
+        private bool _disposed;
+
+        public InternalMemberTests()
+        {
+            _tempDirectory = Path.Combine(Path.GetTempPath(), $"InternalTests_{Guid.NewGuid()}");
+            Directory.CreateDirectory(_tempDirectory);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing && Directory.Exists(_tempDirectory))
+                {
+                    try { Directory.Delete(_tempDirectory, true); }
+                    catch { /* Ignore cleanup errors */ }
+                }
+                _disposed = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalMembers_ExcludedByDefault()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService(); // Default: IncludeInternalMembers = false
+
+            var sourceCode = @"
+namespace Test
+{
+    public class DataService
+    {
+        public void PublicMethod() { }
+        internal void InternalMethod() { }
+        private void PrivateMethod() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result[0].Members.Should().HaveCount(1);
+            result[0].Members.Should().Contain(m => m.Name == "PublicMethod");
+            result[0].Members.Should().NotContain(m => m.Name == "InternalMethod");
+            result[0].Members.Should().NotContain(m => m.Name == "PrivateMethod");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalMembers_IncludedWithOption()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class DataService
+    {
+        public void PublicMethod() { }
+        internal void InternalMethod() { }
+        private void PrivateMethod() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result[0].Members.Should().HaveCount(2);
+            result[0].Members.Should().Contain(m => m.Name == "PublicMethod");
+            result[0].Members.Should().Contain(m => m.Name == "InternalMethod");
+            result[0].Members.Should().NotContain(m => m.Name == "PrivateMethod");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalProperties_IncludedWithOption()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class Config
+    {
+        public string PublicSetting { get; set; }
+        internal string InternalSetting { get; set; }
+        private string PrivateSetting { get; set; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result[0].Members.Should().HaveCount(2);
+            result[0].Members.Should().Contain(m => m.Name == "PublicSetting");
+            result[0].Members.Should().Contain(m => m.Name == "InternalSetting");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalEvents_IncludedWithOption()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+using System;
+
+namespace Test
+{
+    public class EventManager
+    {
+        public event EventHandler PublicEvent;
+        internal event EventHandler InternalEvent;
+        private event EventHandler PrivateEvent;
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result[0].Members.Should().HaveCount(2);
+            result[0].Members.Should().Contain(m => m.Name == "PublicEvent");
+            result[0].Members.Should().Contain(m => m.Name == "InternalEvent");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalIndexers_IncludedWithOption()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class DataStore
+    {
+        public string this[int index]
+        {
+            get { return null; }
+            set { }
+        }
+
+        internal string this[string key]
+        {
+            get { return null; }
+        }
+
+        private string this[long id]
+        {
+            get { return null; }
+        }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result[0].Members.Should().HaveCount(2);
+            result[0].Members.Count(m => m.Type == MemberType.Indexer).Should().Be(2);
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalClass_ExcludedByDefault()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var sourceCode = @"
+namespace Test
+{
+    public class PublicClass
+    {
+        public void Method() { }
+    }
+
+    internal class InternalClass
+    {
+        public void Method() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].ClassName.Should().Be("PublicClass");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalClass_IncludedWithOption()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class PublicClass
+    {
+        public void Method() { }
+    }
+
+    internal class InternalClass
+    {
+        public void Method() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result.Should().HaveCount(2);
+            result.Should().Contain(c => c.ClassName == "PublicClass");
+            result.Should().Contain(c => c.ClassName == "InternalClass");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_ImplicitInternalClass_IncludedWithOption()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    class ImplicitInternalClass  // No access modifier = internal
+    {
+        public void Method() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].ClassName.Should().Be("ImplicitInternalClass");
+        }
+
+        [Fact]
+        public async Task GenerateInterface_WithInternalMembers_CreatesValidInterface()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class ApiService
+    {
+        public void PublicApi() { }
+        internal void InternalApi() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var interfaceCode = service.GenerateInterface(
+                "IApiService",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            interfaceCode.Should().Contain("public interface IApiService");
+            interfaceCode.Should().Contain("void PublicApi();");
+            interfaceCode.Should().Contain("void InternalApi();");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_MixedAccessLevels_FiltersCorrectly()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class MultiAccessService
+    {
+        public void PublicMethod() { }
+        internal void InternalMethod() { }
+        protected void ProtectedMethod() { }
+        protected internal void ProtectedInternalMethod() { }
+        private void PrivateMethod() { }
+        private protected void PrivateProtectedMethod() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            // Should include: public, internal, protected internal
+            // Should exclude: protected, private, private protected
+            result[0].Members.Should().HaveCountGreaterThanOrEqualTo(2);
+            result[0].Members.Should().Contain(m => m.Name == "PublicMethod");
+            result[0].Members.Should().Contain(m => m.Name == "InternalMethod");
+            result[0].Members.Should().NotContain(m => m.Name == "PrivateMethod");
+            result[0].Members.Should().NotContain(m => m.Name == "ProtectedMethod");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalStaticMembers_StillExcluded()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class Utilities
+    {
+        public static void PublicStaticMethod() { }
+        internal static void InternalStaticMethod() { }
+        public void PublicInstanceMethod() { }
+        internal void InternalInstanceMethod() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            // Static members should be excluded even if public or internal
+            result[0].Members.Should().HaveCount(2);
+            result[0].Members.Should().Contain(m => m.Name == "PublicInstanceMethod");
+            result[0].Members.Should().Contain(m => m.Name == "InternalInstanceMethod");
+            result[0].Members.Should().NotContain(m => m.Name == "PublicStaticMethod");
+            result[0].Members.Should().NotContain(m => m.Name == "InternalStaticMethod");
+        }
+
+        private string CreateTempFile(string content)
+        {
+            var fileName = $"Test_{Guid.NewGuid()}.cs";
+            var filePath = Path.Combine(_tempDirectory, fileName);
+            File.WriteAllText(filePath, content);
+            return filePath;
+        }
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/Services/OperatorOverloadGenerationTests.cs b/InterfaceExtractor.Tests/Services/OperatorOverloadGenerationTests.cs
new file mode 100644
index 0000000..314d068
--- /dev/null
+++ b/InterfaceExtractor.Tests/Services/OperatorOverloadGenerationTests.cs
@@ -0,0 +1,95 @@
+using FluentAssertions;
+using InterfaceExtractor.Options;
+using InterfaceExtractor.Services;
+using Xunit;
+
+namespace InterfaceExtractor.Tests.Services
+{
+    public class OperatorOverloadGenerationTests
+    {
+        [Fact]
+        public void GenerateInterface_WithOperators_FormatsCorrectly()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                IncludeOperatorOverloads = true
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var classInfo = new ExtractedClassInfo
+            {
+                ClassName = "Vector",
+                Namespace = "Math",
+                Usings = ["using System;"],
+                Members =
+                [
+                    new MemberInfo
+                    {
+                        Type = MemberType.Property,
+                        Signature = "double X { get; set; }",
+                        Name = "X"
+                    },
+                    new MemberInfo
+                    {
+                        Type = MemberType.Operator,
+                        Signature = "Vector operator +(Vector a, Vector b)",
+                        Name = "operator +",
+                        ReturnType = "Vector"
+                    }
+                ]
+            };
+
+            // Act
+            var result = service.GenerateInterface("IVector", classInfo, classInfo.Members);
+
+            // Assert
+            result.Should().Contain("namespace Math.Interfaces");
+            result.Should().Contain("public interface IVector");
+            result.Should().Contain("double X { get; set; }");
+            result.Should().Contain("Vector operator +(Vector a, Vector b);");
+        }
+
+        [Fact]
+        public void GenerateInterface_WithConversionOperators_FormatsCorrectly()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                IncludeOperatorOverloads = true
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var classInfo = new ExtractedClassInfo
+            {
+                ClassName = "Money",
+                Namespace = "Finance",
+                Usings = [],
+                Members =
+                [
+                    new MemberInfo
+                    {
+                        Type = MemberType.Operator,
+                        Signature = "implicit operator double(Money m)",
+                        Name = "implicit operator double",
+                        ReturnType = "double"
+                    },
+                    new MemberInfo
+                    {
+                        Type = MemberType.Operator,
+                        Signature = "explicit operator string(Money m)",
+                        Name = "explicit operator string",
+                        ReturnType = "string"
+                    }
+                ]
+            };
+
+            // Act
+            var result = service.GenerateInterface("IMoney", classInfo, classInfo.Members);
+
+            // Assert
+            result.Should().Contain("implicit operator double(Money m);");
+            result.Should().Contain("explicit operator string(Money m);");
+        }
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/Services/OptionsIntegrationTests.cs b/InterfaceExtractor.Tests/Services/OptionsIntegrationTests.cs
new file mode 100644
index 0000000..3726ee7
--- /dev/null
+++ b/InterfaceExtractor.Tests/Services/OptionsIntegrationTests.cs
@@ -0,0 +1,596 @@
+using FluentAssertions;
+using InterfaceExtractor.Options;
+using InterfaceExtractor.Services;
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace InterfaceExtractor.Tests.Services
+{
+    public class OptionsIntegrationTests : IDisposable
+    {
+        private readonly string _tempDirectory;
+        private bool _disposed;
+
+        public OptionsIntegrationTests()
+        {
+            _tempDirectory = Path.Combine(Path.GetTempPath(), $"OptionsTests_{Guid.NewGuid()}");
+            Directory.CreateDirectory(_tempDirectory);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing && Directory.Exists(_tempDirectory))
+                {
+                    try { Directory.Delete(_tempDirectory, true); }
+                    catch { /* Ignore cleanup errors */ }
+                }
+                _disposed = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        #region Options Tests
+
+        [Fact]
+        public void ExtractorOptions_HasCorrectDefaults()
+        {
+            // Arrange & Act
+            var options = new ExtractorOptions();
+
+            // Assert
+            options.InterfacesFolderName.Should().Be("Interfaces");
+            options.InterfacePrefix.Should().Be("I");
+            options.InterfacesNamespaceSuffix.Should().Be(".Interfaces");
+            options.AutoUpdateClass.Should().BeTrue();
+            options.AddUsingDirective.Should().BeTrue();
+            options.WarnIfNoIPrefix.Should().BeTrue();
+            options.IncludeOperatorOverloads.Should().BeFalse();
+            options.IncludeFileHeader.Should().BeFalse();
+            options.MemberSeparatorLines.Should().Be(1);
+            options.SortMembers.Should().BeFalse();
+            options.GroupByMemberType.Should().BeFalse();
+        }
+
+        [Fact]
+        public void ExtractorOptions_CanModifySettings()
+        {
+            // Arrange
+            var options = new ExtractorOptions();
+
+            // Act
+            options.InterfacesFolderName = "Contracts";
+            options.InterfacePrefix = "X";
+            options.InterfacesNamespaceSuffix = ".Contracts";
+            options.AutoUpdateClass = false;
+            options.IncludeOperatorOverloads = true;
+
+            // Assert
+            options.InterfacesFolderName.Should().Be("Contracts");
+            options.InterfacePrefix.Should().Be("X");
+            options.InterfacesNamespaceSuffix.Should().Be(".Contracts");
+            options.AutoUpdateClass.Should().BeFalse();
+            options.IncludeOperatorOverloads.Should().BeTrue();
+        }
+
+        [Fact]
+        public async Task Service_RespectsCustomFolderName()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                InterfacesFolderName = "CustomFolder"
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class TestClass
+    {
+        public string Name { get; set; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var interfaceCode = service.GenerateInterface("ITestClass", classInfos[0], classInfos[0].Members);
+
+            // Assert - Folder name doesn't affect namespace, only the namespace suffix does
+            interfaceCode.Should().Contain("namespace Test.Interfaces"); // Still uses .Interfaces suffix
+        }
+
+        [Fact]
+        public async Task Service_RespectsCustomNamespaceSuffix()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                InterfacesNamespaceSuffix = ".Contracts"
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace MyApp.Services
+{
+    public class UserService
+    {
+        public string GetUser() { return null; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var interfaceCode = service.GenerateInterface("IUserService", classInfos[0], classInfos[0].Members);
+
+            // Assert
+            interfaceCode.Should().Contain("namespace MyApp.Services.Contracts");
+        }
+
+        [Fact]
+        public void Service_WithAutoUpdateDisabled_DoesNotUpdateClass()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                AutoUpdateClass = false
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class TestClass
+    {
+        public string Name { get; set; }
+    }
+}";
+
+            // Act
+            var result = service.AppendInterfaceToClass(sourceCode, "TestClass", "ITestClass", "Test.Interfaces");
+
+            // Assert
+            result.Should().Be(sourceCode); // Unchanged
+        }
+
+        [Fact]
+        public void Service_WithAddUsingDirectiveDisabled_UsesFullyQualifiedName()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                AutoUpdateClass = true,
+                AddUsingDirective = false
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class TestClass
+    {
+        public string Name { get; set; }
+    }
+}";
+
+            // Act
+            var result = service.AppendInterfaceToClass(sourceCode, "TestClass", "ITestClass", "Test.Interfaces");
+
+            // Assert - Should use fully qualified name since no using directive
+            result.Should().Contain("public class TestClass : Test.Interfaces.ITestClass");
+            result.Should().NotContain("using Test.Interfaces;");
+        }
+
+        [Fact]
+        public void Service_WithAddUsingDirectiveEnabled_UsesSimpleNameAndAddsUsing()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                AutoUpdateClass = true,
+                AddUsingDirective = true
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class TestClass
+    {
+        public string Name { get; set; }
+    }
+}";
+
+            // Act
+            var result = service.AppendInterfaceToClass(sourceCode, "TestClass", "ITestClass", "Test.Interfaces");
+
+            // Assert - Should use simple name and add using directive
+            result.Should().Contain("public class TestClass : ITestClass");
+            result.Should().NotContain("Test.Interfaces.ITestClass");
+            result.Should().Contain("using Test.Interfaces;");
+        }
+
+        [Fact]
+        public void Service_FiltersOutSelfReferencingUsings()
+        {
+            // Arrange
+            var service = new InterfaceExtractorService();
+
+            var classInfo = new ExtractedClassInfo
+            {
+                ClassName = "TestClass",
+                Namespace = "MyApp.Data",
+                Usings =
+                [
+                    "using System;",
+                    "using MyApp.Models;",
+                    "using MyApp.Data.Interfaces;" // This should be filtered out!
+                ],
+                Members =
+                [
+                    new MemberInfo
+                    {
+                        Type = MemberType.Property,
+                        Signature = "string Name { get; set; }",
+                        Name = "Name"
+                    }
+                ]
+            };
+
+            // Act
+            var interfaceCode = service.GenerateInterface("ITestClass", classInfo, classInfo.Members);
+
+            // Assert - Should NOT include the self-referencing using
+            interfaceCode.Should().Contain("using System;");
+            interfaceCode.Should().Contain("using MyApp.Models;");
+            interfaceCode.Should().NotContain("using MyApp.Data.Interfaces;",
+                "interface should not include using statement for its own namespace");
+            interfaceCode.Should().Contain("namespace MyApp.Data.Interfaces");
+        }
+
+        #endregion Options Tests
+
+        #region Operator Overload Tests
+
+        [Fact]
+        public async Task Service_WithOperatorsDisabled_ExcludesOperators()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                IncludeOperatorOverloads = false // Default
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class Vector
+    {
+        public double X { get; set; }
+
+        public static Vector operator +(Vector a, Vector b)
+        {
+            return null;
+        }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            classInfos[0].Members.Should().HaveCount(1); // Only property, no operator
+            classInfos[0].Members[0].Type.Should().Be(MemberType.Property);
+        }
+
+        [Fact]
+        public async Task Service_WithOperatorsEnabled_IncludesOperators()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                IncludeOperatorOverloads = true
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class Vector
+    {
+        public double X { get; set; }
+
+        public static Vector operator +(Vector a, Vector b)
+        {
+            return null;
+        }
+
+        public static Vector operator -(Vector a, Vector b)
+        {
+            return null;
+        }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            classInfos[0].Members.Should().HaveCount(3); // Property + 2 operators
+            classInfos[0].Members.Should().Contain(m => m.Type == MemberType.Operator && m.Name.Contains("+"));
+            classInfos[0].Members.Should().Contain(m => m.Type == MemberType.Operator && m.Name.Contains("-"));
+        }
+
+        [Fact]
+        public async Task Service_ExtractsAllOperatorTypes()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                IncludeOperatorOverloads = true
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class ComplexNumber
+    {
+        public double Real { get; set; }
+        public double Imaginary { get; set; }
+
+        // Binary operators
+        public static ComplexNumber operator +(ComplexNumber a, ComplexNumber b) { return null; }
+        public static ComplexNumber operator -(ComplexNumber a, ComplexNumber b) { return null; }
+        public static ComplexNumber operator *(ComplexNumber a, ComplexNumber b) { return null; }
+        public static ComplexNumber operator /(ComplexNumber a, ComplexNumber b) { return null; }
+
+        // Comparison operators
+        public static bool operator ==(ComplexNumber a, ComplexNumber b) { return true; }
+        public static bool operator !=(ComplexNumber a, ComplexNumber b) { return false; }
+
+        // Unary operators
+        public static ComplexNumber operator -(ComplexNumber a) { return null; }
+        public static ComplexNumber operator !(ComplexNumber a) { return null; }
+
+        // Conversion operators
+        public static implicit operator string(ComplexNumber c) { return null; }
+        public static explicit operator double(ComplexNumber c) { return 0; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            var operators = classInfos[0].Members.Where(m => m.Type == MemberType.Operator).ToList();
+            operators.Should().HaveCount(10);
+            operators.Should().Contain(o => o.Signature.Contains("operator +"));
+            operators.Should().Contain(o => o.Signature.Contains("operator =="));
+            operators.Should().Contain(o => o.Signature.Contains("implicit operator"));
+            operators.Should().Contain(o => o.Signature.Contains("explicit operator"));
+        }
+
+        #endregion Operator Overload Tests
+
+        #region Template Tests
+
+        [Fact]
+        public async Task Service_WithFileHeader_IncludesHeader()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                IncludeFileHeader = true,
+                FileHeaderTemplate = "// Custom Header\n// File: {FileName}"
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class TestClass
+    {
+        public string Name { get; set; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var interfaceCode = service.GenerateInterface("ITestClass", classInfos[0], classInfos[0].Members);
+
+            // Assert
+            interfaceCode.Should().StartWith("// Custom Header");
+            interfaceCode.Should().Contain("// File: ITestClass.cs");
+        }
+
+        [Fact]
+        public async Task Service_WithGrouping_GroupsMembersByType()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                GroupByMemberType = true
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+using System;
+
+namespace Test
+{
+    public class TestClass
+    {
+        public void Method1() { }
+        public string Property1 { get; set; }
+        public void Method2() { }
+        public int Property2 { get; set; }
+        public event EventHandler Event1;
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var interfaceCode = service.GenerateInterface("ITestClass", classInfos[0], classInfos[0].Members);
+
+            // Assert
+            interfaceCode.Should().Contain("// Properties");
+            interfaceCode.Should().Contain("// Methods");
+            interfaceCode.Should().Contain("// Events");
+
+            // Properties should come before methods (based on GetMemberTypeOrder)
+            var propertiesIndex = interfaceCode.IndexOf("// Properties");
+            var methodsIndex = interfaceCode.IndexOf("// Methods");
+            propertiesIndex.Should().BeLessThan(methodsIndex);
+        }
+
+        [Fact]
+        public async Task Service_WithSorting_SortsMembersAlphabetically()
+        {
+            // Arrange
+            var options = new ExtractorOptions
+            {
+                SortMembers = true
+            };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public class TestClass
+    {
+        public string Zebra { get; set; }
+        public string Alpha { get; set; }
+        public string Beta { get; set; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var interfaceCode = service.GenerateInterface("ITestClass", classInfos[0], classInfos[0].Members);
+
+            // Assert
+            var alphaIndex = interfaceCode.IndexOf("string Alpha");
+            var betaIndex = interfaceCode.IndexOf("string Beta");
+            var zebraIndex = interfaceCode.IndexOf("string Zebra");
+
+            alphaIndex.Should().BeLessThan(betaIndex);
+            betaIndex.Should().BeLessThan(zebraIndex);
+        }
+
+        [Fact]
+        public async Task Service_WithZeroSeparatorLines_HasNoBlankLinesBetweenMembers()
+        {
+            // Arrange
+            var options = new ExtractorOptions { MemberSeparatorLines = 0 };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = "namespace Test { public class TestClass { public string A { get; set; } public string B { get; set; } } }";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var interfaceCode = service.GenerateInterface("ITestClass", classInfos[0], classInfos[0].Members);
+
+            // Assert - with 0 separator lines, properties should be consecutive (no blank line between)
+            var lines = interfaceCode.Split(["\r\n", "\n"], StringSplitOptions.None);
+            var aIndex = Array.FindIndex(lines, l => l.Contains("string A"));
+            var bIndex = Array.FindIndex(lines, l => l.Contains("string B"));
+
+            // Count blank lines between them
+            var blankLines = 0;
+            for (int i = aIndex + 1; i < bIndex; i++)
+            {
+                if (string.IsNullOrWhiteSpace(lines[i]))
+                {
+                    blankLines++;
+                }
+            }
+
+            blankLines.Should().Be(0, "with 0 separator lines, there should be no blank lines between members");
+        }
+
+        [Fact]
+        public async Task Service_WithMultipleSeparatorLines_AddsBlankLinesBetweenMembers()
+        {
+            // Arrange
+            var optionsWithOne = new ExtractorOptions { MemberSeparatorLines = 1 };
+            var optionsWithThree = new ExtractorOptions { MemberSeparatorLines = 3 };
+
+            var serviceOne = new InterfaceExtractorService(optionsWithOne);
+            var serviceThree = new InterfaceExtractorService(optionsWithThree);
+
+            var sourceCode = "namespace Test { public class TestClass { public string A { get; set; } public string B { get; set; } } }";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await serviceOne.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var codeWithOne = serviceOne.GenerateInterface("ITestClass", classInfos[0], classInfos[0].Members);
+            var codeWithThree = serviceThree.GenerateInterface("ITestClass", classInfos[0], classInfos[0].Members);
+
+            // Assert - Count blank lines between the properties
+            var linesOne = codeWithOne.Split(["\r\n", "\n"], StringSplitOptions.None);
+            var linesThree = codeWithThree.Split(["\r\n", "\n"], StringSplitOptions.None);
+
+            var aIndexOne = Array.FindIndex(linesOne, l => l.Contains("string A"));
+            var bIndexOne = Array.FindIndex(linesOne, l => l.Contains("string B"));
+
+            var aIndexThree = Array.FindIndex(linesThree, l => l.Contains("string A"));
+            var bIndexThree = Array.FindIndex(linesThree, l => l.Contains("string B"));
+
+            // Count blank lines between them
+            var blankLinesOne = 0;
+            for (int i = aIndexOne + 1; i < bIndexOne; i++)
+            {
+                if (string.IsNullOrWhiteSpace(linesOne[i]))
+                {
+                    blankLinesOne++;
+                }
+            }
+
+            var blankLinesThree = 0;
+            for (int i = aIndexThree + 1; i < bIndexThree; i++)
+            {
+                if (string.IsNullOrWhiteSpace(linesThree[i]))
+                {
+                    blankLinesThree++;
+                }
+            }
+
+            blankLinesOne.Should().Be(1, "with MemberSeparatorLines=1, there should be 1 blank line");
+            blankLinesThree.Should().Be(3, "with MemberSeparatorLines=3, there should be 3 blank lines");
+        }
+
+        #endregion Template Tests
+
+        #region Helper Methods
+
+        private string CreateTempFile(string content)
+        {
+            var fileName = $"Test_{Guid.NewGuid()}.cs";
+            var filePath = Path.Combine(_tempDirectory, fileName);
+            File.WriteAllText(filePath, content);
+            return filePath;
+        }
+
+        #endregion Helper Methods
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/Services/PartialClassTests.cs b/InterfaceExtractor.Tests/Services/PartialClassTests.cs
new file mode 100644
index 0000000..5034c3e
--- /dev/null
+++ b/InterfaceExtractor.Tests/Services/PartialClassTests.cs
@@ -0,0 +1,416 @@
+using FluentAssertions;
+using InterfaceExtractor.Options;
+using InterfaceExtractor.Services;
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace InterfaceExtractor.Tests.Services
+{
+    /// <summary>
+    /// Tests for partial class support (v1.2.0)
+    /// </summary>
+    public class PartialClassTests : IDisposable
+    {
+        private readonly string _tempDirectory;
+        private bool _disposed;
+
+        public PartialClassTests()
+        {
+            _tempDirectory = Path.Combine(Path.GetTempPath(), $"PartialTests_{Guid.NewGuid()}");
+            Directory.CreateDirectory(_tempDirectory);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing && Directory.Exists(_tempDirectory))
+                {
+                    try { Directory.Delete(_tempDirectory, true); }
+                    catch { /* Ignore cleanup errors */ }
+                }
+                _disposed = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_SinglePartialFile_DetectsPartialModifier()
+        {
+            // Arrange
+            var options = new ExtractorOptions { AnalyzePartialClasses = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public partial class UserService
+    {
+        public void GetUser() { }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath, _tempDirectory);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].IsPartial.Should().BeTrue();
+            result[0].Members.Should().HaveCount(1);
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_MultiplePartialFiles_CombinesMembers()
+        {
+            // Arrange
+            var options = new ExtractorOptions { AnalyzePartialClasses = true };
+            var service = new InterfaceExtractorService(options);
+
+            var file1Code = @"
+namespace Test
+{
+    public partial class UserService
+    {
+        public void GetUser(int id) { }
+        public void UpdateUser() { }
+    }
+}";
+            var file2Code = @"
+namespace Test
+{
+    public partial class UserService
+    {
+        public void DeleteUser(int id) { }
+        public void ListUsers() { }
+    }
+}";
+            CreateTempFile(file1Code, "UserService.Part1.cs");
+            var file2Path = CreateTempFile(file2Code, "UserService.Part2.cs");
+
+            // Act - analyze from file2
+            var result = await service.AnalyzeClassesAsync(file2Path, _tempDirectory);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].IsPartial.Should().BeTrue();
+            result[0].Members.Should().HaveCount(4); // All 4 methods combined
+            result[0].Members.Should().Contain(m => m.Name == "GetUser");
+            result[0].Members.Should().Contain(m => m.Name == "UpdateUser");
+            result[0].Members.Should().Contain(m => m.Name == "DeleteUser");
+            result[0].Members.Should().Contain(m => m.Name == "ListUsers");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_PartialClassesInDifferentNamespaces_DoesNotCombine()
+        {
+            // Arrange
+            var options = new ExtractorOptions { AnalyzePartialClasses = true };
+            var service = new InterfaceExtractorService(options);
+
+            var file1Code = @"
+namespace Test.Services
+{
+    public partial class UserService
+    {
+        public void GetUser() { }
+    }
+}";
+            var file2Code = @"
+namespace Test.Data
+{
+    public partial class UserService
+    {
+        public void SaveUser() { }
+    }
+}";
+            CreateTempFile(file1Code, "UserService1.cs");
+            var file2Path = CreateTempFile(file2Code, "UserService2.cs");
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(file2Path, _tempDirectory);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].Namespace.Should().Be("Test.Data");
+            result[0].Members.Should().HaveCount(1); // Only SaveUser
+            result[0].Members.Should().NotContain(m => m.Name == "GetUser");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_PartialWithDuplicateSignatures_NoDuplicates()
+        {
+            // Arrange
+            var options = new ExtractorOptions { AnalyzePartialClasses = true };
+            var service = new InterfaceExtractorService(options);
+
+            var file1Code = @"
+namespace Test
+{
+    public partial class DataService
+    {
+        public string Name { get; set; }
+        public void Process() { }
+    }
+}";
+            var file2Code = @"
+namespace Test
+{
+    public partial class DataService
+    {
+        public string Name { get; set; }  // Duplicate
+        public void Execute() { }
+    }
+}";
+            CreateTempFile(file1Code, "DataService1.cs");
+            var file2Path = CreateTempFile(file2Code, "DataService2.cs");
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(file2Path, _tempDirectory);
+
+            // Assert
+            result[0].Members.Should().HaveCount(3); // Name (once), Process, Execute
+            result[0].Members.Count(m => m.Name == "Name").Should().Be(1);
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_PartialAnalysisDisabled_OnlyCurrentFile()
+        {
+            // Arrange
+            var options = new ExtractorOptions { AnalyzePartialClasses = false };
+            var service = new InterfaceExtractorService(options);
+
+            var file1Code = @"
+namespace Test
+{
+    public partial class UserService
+    {
+        public void GetUser() { }
+    }
+}";
+            var file2Code = @"
+namespace Test
+{
+    public partial class UserService
+    {
+        public void DeleteUser() { }
+    }
+}";
+            CreateTempFile(file1Code, "UserService1.cs");
+            var file2Path = CreateTempFile(file2Code, "UserService2.cs");
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(file2Path, _tempDirectory);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].Members.Should().HaveCount(1); // Only DeleteUser from current file
+            result[0].Members.Should().Contain(m => m.Name == "DeleteUser");
+            result[0].Members.Should().NotContain(m => m.Name == "GetUser");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_PartialWithProperties_CombinesAll()
+        {
+            // Arrange
+            var options = new ExtractorOptions { AnalyzePartialClasses = true };
+            var service = new InterfaceExtractorService(options);
+
+            var file1Code = @"
+namespace Test
+{
+    public partial class Person
+    {
+        public string FirstName { get; set; }
+        public string LastName { get; set; }
+    }
+}";
+            var file2Code = @"
+namespace Test
+{
+    public partial class Person
+    {
+        public int Age { get; set; }
+        public string Email { get; set; }
+    }
+}";
+            CreateTempFile(file1Code, "Person1.cs");
+            var file2Path = CreateTempFile(file2Code, "Person2.cs");
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(file2Path, _tempDirectory);
+
+            // Assert
+            result[0].Members.Should().HaveCount(4);
+            result[0].Members.Should().Contain(m => m.Name == "FirstName");
+            result[0].Members.Should().Contain(m => m.Name == "LastName");
+            result[0].Members.Should().Contain(m => m.Name == "Age");
+            result[0].Members.Should().Contain(m => m.Name == "Email");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_PartialWithEvents_CombinesAll()
+        {
+            // Arrange
+            var options = new ExtractorOptions { AnalyzePartialClasses = true };
+            var service = new InterfaceExtractorService(options);
+
+            var file1Code = @"
+using System;
+
+namespace Test
+{
+    public partial class EventManager
+    {
+        public event EventHandler Started;
+        public void Start() { }
+    }
+}";
+            var file2Code = @"
+using System;
+
+namespace Test
+{
+    public partial class EventManager
+    {
+        public event EventHandler Stopped;
+        public void Stop() { }
+    }
+}";
+            CreateTempFile(file1Code, "EventManager1.cs");
+            var file2Path = CreateTempFile(file2Code, "EventManager2.cs");
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(file2Path, _tempDirectory);
+
+            // Assert
+            result[0].Members.Should().HaveCount(4); // 2 events + 2 methods
+            result[0].Members.Should().Contain(m => m.Type == MemberType.Event && m.Name == "Started");
+            result[0].Members.Should().Contain(m => m.Type == MemberType.Event && m.Name == "Stopped");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_PartialRecordNotSupported_OnlyAnalyzesCurrentFile()
+        {
+            // Arrange - partial records exist but are uncommon
+            var options = new ExtractorOptions { AnalyzePartialClasses = true };
+            var service = new InterfaceExtractorService(options);
+
+            var file1Code = @"
+namespace Test
+{
+    public partial record UserRecord
+    {
+        public string Name { get; init; }
+    }
+}";
+            var file2Code = @"
+namespace Test
+{
+    public partial record UserRecord
+    {
+        public int Age { get; init; }
+    }
+}";
+            CreateTempFile(file1Code, "UserRecord1.cs");
+            var file2Path = CreateTempFile(file2Code, "UserRecord2.cs");
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(file2Path, _tempDirectory);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].IsRecord.Should().BeTrue();
+            result[0].IsPartial.Should().BeTrue();
+            // Should combine members from both files
+            result[0].Members.Should().HaveCount(2);
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_NonPartialClass_IgnoresOtherFiles()
+        {
+            // Arrange
+            var options = new ExtractorOptions { AnalyzePartialClasses = true };
+            var service = new InterfaceExtractorService(options);
+
+            var file1Code = @"
+namespace Test
+{
+    public class UserService
+    {
+        public void GetUser() { }
+    }
+}";
+            var file2Code = @"
+namespace Test
+{
+    public class UserService  // Same name but not partial
+    {
+        public void DeleteUser() { }
+    }
+}";
+            CreateTempFile(file1Code, "UserService1.cs");
+            var file2Path = CreateTempFile(file2Code, "UserService2.cs");
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(file2Path, _tempDirectory);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].IsPartial.Should().BeFalse();
+            result[0].Members.Should().HaveCount(1); // Only DeleteUser from current file
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_PartialWithInvalidFiles_SkipsInvalidFiles()
+        {
+            // Arrange
+            var options = new ExtractorOptions { AnalyzePartialClasses = true };
+            var service = new InterfaceExtractorService(options);
+
+            var validCode = @"
+namespace Test
+{
+    public partial class DataService
+    {
+        public void GetData() { }
+    }
+}";
+            // This is truly invalid - completely malformed syntax
+            var invalidCode = @"
+namespace Test
+{
+    public partial class DataService @#$%^&*()
+        public void SaveData() { }
+    }
+}";
+            CreateTempFile(invalidCode, "DataService1.cs"); // Invalid file
+            var validFilePath = CreateTempFile(validCode, "DataService2.cs");
+
+            // Act - should not throw, just skip invalid files
+            var result = await service.AnalyzeClassesAsync(validFilePath, _tempDirectory);
+
+            // Assert - Only GetData from the valid file should be included
+            result.Should().HaveCount(1);
+            result[0].Members.Should().HaveCount(1);
+            result[0].Members.Should().Contain(m => m.Name == "GetData");
+            result[0].Members.Should().NotContain(m => m.Name == "SaveData");
+        }
+
+        private string CreateTempFile(string content, string fileName = null)
+        {
+            fileName ??= $"Test_{Guid.NewGuid()}.cs";
+            var filePath = Path.Combine(_tempDirectory, fileName);
+            File.WriteAllText(filePath, content);
+            return filePath;
+        }
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/Services/RecordTypeTests.cs b/InterfaceExtractor.Tests/Services/RecordTypeTests.cs
new file mode 100644
index 0000000..14320da
--- /dev/null
+++ b/InterfaceExtractor.Tests/Services/RecordTypeTests.cs
@@ -0,0 +1,337 @@
+using FluentAssertions;
+using InterfaceExtractor.Options;
+using InterfaceExtractor.Services;
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace InterfaceExtractor.Tests.Services
+{
+    /// <summary>
+    /// Tests for record type support (v1.2.0)
+    /// </summary>
+    public class RecordTypeTests : IDisposable
+    {
+        private readonly InterfaceExtractorService _service;
+        private readonly string _tempDirectory;
+        private bool _disposed;
+
+        public RecordTypeTests()
+        {
+            _service = new InterfaceExtractorService();
+            _tempDirectory = Path.Combine(Path.GetTempPath(), $"RecordTests_{Guid.NewGuid()}");
+            Directory.CreateDirectory(_tempDirectory);
+        }
+
+        protected virtual void Dispose(bool disposing)
+        {
+            if (!_disposed)
+            {
+                if (disposing && Directory.Exists(_tempDirectory))
+                {
+                    try { Directory.Delete(_tempDirectory, true); }
+                    catch { /* Ignore cleanup errors */ }
+                }
+                _disposed = true;
+            }
+        }
+
+        public void Dispose()
+        {
+            Dispose(true);
+            GC.SuppressFinalize(this);
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_WithSimpleRecord_ExtractsCorrectly()
+        {
+            // Arrange
+            var sourceCode = @"
+namespace Test
+{
+    public record Person(string FirstName, string LastName);
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await _service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].ClassName.Should().Be("Person");
+            result[0].IsRecord.Should().BeTrue();
+            result[0].Members.Should().HaveCount(2); // FirstName and LastName from primary constructor
+            result[0].Members.Should().Contain(m => m.Name == "FirstName");
+            result[0].Members.Should().Contain(m => m.Name == "LastName");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_WithRecordWithMethods_ExtractsAllMembers()
+        {
+            // Arrange
+            var sourceCode = @"
+using System;
+
+namespace Test
+{
+    public record Person
+    {
+        public string FirstName { get; init; }
+        public string LastName { get; init; }
+        public DateTime BirthDate { get; init; }
+
+        public int Age => (DateTime.Now - BirthDate).Days / 365;
+
+        public string GetFullName() => $""{FirstName} {LastName}"";
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await _service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].IsRecord.Should().BeTrue();
+            result[0].Members.Should().HaveCount(5); // 4 properties + 1 method
+            result[0].Members.Should().Contain(m => m.Name == "FirstName");
+            result[0].Members.Should().Contain(m => m.Name == "Age");
+            result[0].Members.Should().Contain(m => m.Name == "GetFullName");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_WithRecordStruct_ExtractsCorrectly()
+        {
+            // Arrange
+            var sourceCode = @"
+namespace Test
+{
+    public record struct Point(int X, int Y);
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await _service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].ClassName.Should().Be("Point");
+            result[0].IsRecord.Should().BeTrue();
+            result[0].Members.Should().HaveCount(2); // X and Y from primary constructor
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_WithReadOnlyRecordProperties_DetectsCorrectly()
+        {
+            // Arrange
+            var sourceCode = @"
+namespace Test
+{
+    public record Product
+    {
+        public string Name { get; init; }
+        public decimal Price { get; set; }
+        public string Category { get; }
+
+        public Product()
+        {
+            Category = ""Default"";
+        }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await _service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            var members = result[0].Members;
+
+            // init accessor is converted to get for interfaces
+            members.First(m => m.Name == "Name").Signature.Should().Contain("{ get; }");
+            members.First(m => m.Name == "Price").Signature.Should().Contain("{ get; set; }");
+            members.First(m => m.Name == "Category").Signature.Should().Contain("{ get; }");
+        }
+
+        [Fact]
+        public async Task GenerateInterface_FromRecord_CreatesValidInterface()
+        {
+            // Arrange
+            var sourceCode = @"
+namespace Test
+{
+    public record Person(string FirstName, string LastName)
+    {
+        public int Age { get; set; }
+        public string GetFullName() => $""{FirstName} {LastName}"";
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+            var classInfos = await _service.AnalyzeClassesAsync(filePath);
+
+            // Act
+            var interfaceCode = _service.GenerateInterface(
+                "IPerson",
+                classInfos[0],
+                classInfos[0].Members);
+
+            // Assert
+            interfaceCode.Should().Contain("public interface IPerson");
+            // Primary constructor parameters
+            interfaceCode.Should().Contain("string FirstName { get; }");
+            interfaceCode.Should().Contain("string LastName { get; }");
+            // Explicit properties and methods
+            interfaceCode.Should().Contain("int Age { get; set; }");
+            interfaceCode.Should().Contain("string GetFullName();");
+        }
+
+        [Fact]
+        public void AppendInterfaceToRecord_UpdatesRecordDeclaration()
+        {
+            // Arrange
+            var sourceCode = @"
+namespace Test
+{
+    public record Person(string FirstName, string LastName);
+}";
+
+            // Act
+            var result = _service.AppendInterfaceToClass(
+                sourceCode,
+                "Person",
+                "IPerson",
+                "Test.Interfaces");
+
+            // Assert
+            result.Should().Contain("public record Person");
+            result.Should().Contain(": IPerson");
+            result.Should().Contain("using Test.Interfaces;");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_MixedClassesAndRecords_ExtractsBoth()
+        {
+            // Arrange
+            var sourceCode = @"
+namespace Test
+{
+    public class UserService
+    {
+        public void SaveUser() { }
+    }
+
+    public record User(string Name, string Email);
+
+    public class Logger
+    {
+        public void Log(string message) { }
+    }
+
+    public record Settings(bool IsEnabled);
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await _service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result.Should().HaveCount(4);
+            result.Should().Contain(c => c.ClassName == "UserService" && !c.IsRecord);
+            result.Should().Contain(c => c.ClassName == "User" && c.IsRecord);
+            result.Should().Contain(c => c.ClassName == "Logger" && !c.IsRecord);
+            result.Should().Contain(c => c.ClassName == "Settings" && c.IsRecord);
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_RecordWithDocumentation_PreservesDocumentation()
+        {
+            // Arrange
+            var sourceCode = @"
+namespace Test
+{
+    /// <summary>
+    /// Represents a person
+    /// </summary>
+    public record Person
+    {
+        /// <summary>
+        /// Gets the first name
+        /// </summary>
+        public string FirstName { get; init; }
+
+        /// <summary>
+        /// Gets the last name
+        /// </summary>
+        public string LastName { get; init; }
+    }
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await _service.AnalyzeClassesAsync(filePath);
+            var interfaceCode = _service.GenerateInterface("IPerson", result[0], result[0].Members);
+
+            // Assert
+            interfaceCode.Should().Contain("/// <summary>");
+            interfaceCode.Should().Contain("/// Gets the first name");
+            interfaceCode.Should().Contain("/// Gets the last name");
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalRecord_ExcludedByDefault()
+        {
+            // Arrange
+            var sourceCode = @"
+namespace Test
+{
+    public record PublicRecord(string Name);
+    internal record InternalRecord(string Name);
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await _service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result.Should().HaveCount(1);
+            result[0].ClassName.Should().Be("PublicRecord");
+            result[0].Members.Should().HaveCount(1); // Name from primary constructor
+        }
+
+        [Fact]
+        public async Task AnalyzeClassesAsync_InternalRecord_IncludedWithOption()
+        {
+            // Arrange
+            var options = new ExtractorOptions { IncludeInternalMembers = true };
+            var service = new InterfaceExtractorService(options);
+
+            var sourceCode = @"
+namespace Test
+{
+    public record PublicRecord(string Name);
+    internal record InternalRecord(string Name);
+}";
+            var filePath = CreateTempFile(sourceCode);
+
+            // Act
+            var result = await service.AnalyzeClassesAsync(filePath);
+
+            // Assert
+            result.Should().HaveCount(2);
+            result.Should().Contain(c => c.ClassName == "PublicRecord");
+            result.Should().Contain(c => c.ClassName == "InternalRecord");
+            // Each record should have one member (Name)
+            result.ForEach(r => r.Members.Should().HaveCount(1));
+        }
+
+        private string CreateTempFile(string content)
+        {
+            var fileName = $"Test_{Guid.NewGuid()}.cs";
+            var filePath = Path.Combine(_tempDirectory, fileName);
+            File.WriteAllText(filePath, content);
+            return filePath;
+        }
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/UI/ExtractInterfaceDialogTests.cs b/InterfaceExtractor.Tests/UI/ExtractInterfaceDialogTests.cs
index 38c9bff..c447c5a 100644
--- a/InterfaceExtractor.Tests/UI/ExtractInterfaceDialogTests.cs
+++ b/InterfaceExtractor.Tests/UI/ExtractInterfaceDialogTests.cs
@@ -1,10 +1,7 @@
 using FluentAssertions;
 using InterfaceExtractor.UI;
 using Microsoft.CodeAnalysis.CSharp;
-using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
 using Xunit;
 
 namespace InterfaceExtractor.Tests.UI
@@ -62,105 +59,4 @@ public void ValidateInterfaceName_ChecksValidIdentifier(string name, bool should
             }
         }
     }
-
-    public class MemberSelectionItemTests
-    {
-        [Fact]
-        public void IsSelected_RaisesPropertyChanged()
-        {
-            // Arrange
-            var item = new MemberSelectionItem
-            {
-                DisplayText = "string Name { get; set; }",
-                Signature = "string Name { get; set; }",
-                MemberType = "Property",
-                IsSelected = false
-            };
-
-            bool eventRaised = false;
-            item.PropertyChanged += (s, e) =>
-            {
-                if (e.PropertyName == nameof(MemberSelectionItem.IsSelected))
-                    eventRaised = true;
-            };
-
-            // Act
-            item.IsSelected = true;
-
-            // Assert
-            eventRaised.Should().BeTrue();
-            item.IsSelected.Should().BeTrue();
-        }
-
-        [Fact]
-        public void IsSelected_DoesNotRaisePropertyChangedWhenValueUnchanged()
-        {
-            // Arrange
-            var item = new MemberSelectionItem
-            {
-                DisplayText = "string Name { get; set; }",
-                Signature = "string Name { get; set; }",
-                MemberType = "Property",
-                IsSelected = true
-            };
-
-            bool eventRaised = false;
-            item.PropertyChanged += (s, e) =>
-            {
-                if (e.PropertyName == nameof(MemberSelectionItem.IsSelected))
-                    eventRaised = true;
-            };
-
-            // Act
-            item.IsSelected = true; // Same value
-
-            // Assert
-            eventRaised.Should().BeFalse();
-        }
-
-        [Fact]
-        public void MemberSelectionItem_StoresAllProperties()
-        {
-            // Arrange & Act
-            var item = new MemberSelectionItem
-            {
-                DisplayText = "T GetById<T>(int id) where T : class",
-                Signature = "T GetById<T>(int id)",
-                MemberType = "Method",
-                Constraints = "where T : class",
-                IsSelected = true
-            };
-
-            // Assert
-            item.DisplayText.Should().Be("T GetById<T>(int id) where T : class");
-            item.Signature.Should().Be("T GetById<T>(int id)");
-            item.MemberType.Should().Be("Method");
-            item.Constraints.Should().Be("where T : class");
-            item.IsSelected.Should().BeTrue();
-        }
-    }
-
-    public class OverwriteDialogTests
-    {
-        [StaFact]
-        public void Constructor_SetsDefaultChoiceToNo()
-        {
-            // Arrange & Act
-            var dialog = new OverwriteDialog("ITestClass.cs");
-
-            // Assert
-            dialog.Choice.Should().Be(OverwriteChoice.No);
-        }
-
-        [Theory]
-        [InlineData(OverwriteChoice.Yes)]
-        [InlineData(OverwriteChoice.YesToAll)]
-        [InlineData(OverwriteChoice.No)]
-        [InlineData(OverwriteChoice.NoToAll)]
-        public void OverwriteChoice_EnumHasAllExpectedValues(OverwriteChoice choice)
-        {
-            // Assert
-            Enum.IsDefined(typeof(OverwriteChoice), choice).Should().BeTrue();
-        }
-    }
 }
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/UI/MemberSelectionItemTests.cs b/InterfaceExtractor.Tests/UI/MemberSelectionItemTests.cs
new file mode 100644
index 0000000..41bdc16
--- /dev/null
+++ b/InterfaceExtractor.Tests/UI/MemberSelectionItemTests.cs
@@ -0,0 +1,83 @@
+using FluentAssertions;
+using InterfaceExtractor.UI;
+using Xunit;
+
+namespace InterfaceExtractor.Tests.UI
+{
+    public class MemberSelectionItemTests
+    {
+        [Fact]
+        public void IsSelected_RaisesPropertyChanged()
+        {
+            // Arrange
+            var item = new MemberSelectionItem
+            {
+                DisplayText = "string Name { get; set; }",
+                Signature = "string Name { get; set; }",
+                MemberType = "Property",
+                IsSelected = false
+            };
+
+            bool eventRaised = false;
+            item.PropertyChanged += (s, e) =>
+            {
+                if (e.PropertyName == nameof(MemberSelectionItem.IsSelected))
+                    eventRaised = true;
+            };
+
+            // Act
+            item.IsSelected = true;
+
+            // Assert
+            eventRaised.Should().BeTrue();
+            item.IsSelected.Should().BeTrue();
+        }
+
+        [Fact]
+        public void IsSelected_DoesNotRaisePropertyChangedWhenValueUnchanged()
+        {
+            // Arrange
+            var item = new MemberSelectionItem
+            {
+                DisplayText = "string Name { get; set; }",
+                Signature = "string Name { get; set; }",
+                MemberType = "Property",
+                IsSelected = true
+            };
+
+            bool eventRaised = false;
+            item.PropertyChanged += (s, e) =>
+            {
+                if (e.PropertyName == nameof(MemberSelectionItem.IsSelected))
+                    eventRaised = true;
+            };
+
+            // Act
+            item.IsSelected = true; // Same value
+
+            // Assert
+            eventRaised.Should().BeFalse();
+        }
+
+        [Fact]
+        public void MemberSelectionItem_StoresAllProperties()
+        {
+            // Arrange & Act
+            var item = new MemberSelectionItem
+            {
+                DisplayText = "T GetById<T>(int id) where T : class",
+                Signature = "T GetById<T>(int id)",
+                MemberType = "Method",
+                Constraints = "where T : class",
+                IsSelected = true
+            };
+
+            // Assert
+            item.DisplayText.Should().Be("T GetById<T>(int id) where T : class");
+            item.Signature.Should().Be("T GetById<T>(int id)");
+            item.MemberType.Should().Be("Method");
+            item.Constraints.Should().Be("where T : class");
+            item.IsSelected.Should().BeTrue();
+        }
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/UI/OverwriteDialogTests.cs b/InterfaceExtractor.Tests/UI/OverwriteDialogTests.cs
new file mode 100644
index 0000000..65cf9d7
--- /dev/null
+++ b/InterfaceExtractor.Tests/UI/OverwriteDialogTests.cs
@@ -0,0 +1,31 @@
+using FluentAssertions;
+using InterfaceExtractor.UI;
+using System;
+using Xunit;
+
+namespace InterfaceExtractor.Tests.UI
+{
+    public class OverwriteDialogTests
+    {
+        [StaFact]
+        public void Constructor_SetsDefaultChoiceToNo()
+        {
+            // Arrange & Act
+            var dialog = new OverwriteDialog("ITestClass.cs");
+
+            // Assert
+            dialog.Choice.Should().Be(OverwriteChoice.No);
+        }
+
+        [Theory]
+        [InlineData(OverwriteChoice.Yes)]
+        [InlineData(OverwriteChoice.YesToAll)]
+        [InlineData(OverwriteChoice.No)]
+        [InlineData(OverwriteChoice.NoToAll)]
+        public void OverwriteChoice_EnumHasAllExpectedValues(OverwriteChoice choice)
+        {
+            // Assert
+            Enum.IsDefined(typeof(OverwriteChoice), choice).Should().BeTrue();
+        }
+    }
+}
\ No newline at end of file
diff --git a/InterfaceExtractor.Tests/UI/PreviewDialogTests.cs b/InterfaceExtractor.Tests/UI/PreviewDialogTests.cs
new file mode 100644
index 0000000..3b28a7e
--- /dev/null
+++ b/InterfaceExtractor.Tests/UI/PreviewDialogTests.cs
@@ -0,0 +1,100 @@
+using FluentAssertions;
+using InterfaceExtractor.UI;
+using Xunit;
+
+namespace InterfaceExtractor.Tests.UI
+{
+    /// <summary>
+    /// Tests for Preview Dialog
+    /// </summary>
+    public class PreviewDialogTests
+    {
+        [StaFact]
+        public void Constructor_InitializesWithValues()
+        {
+            // Arrange
+            var interfaceName = "ITestClass";
+            var filePath = @"C:\Temp\Interfaces\ITestClass.cs";
+            var interfaceCode = @"
+namespace Test.Interfaces
+{
+    public interface ITestClass
+    {
+        string Name { get; set; }
+    }
+}";
+            // Act
+            var dialog = new PreviewDialog(interfaceName, filePath, interfaceCode);
+
+            // Assert
+            dialog.Should().NotBeNull();
+            dialog.UserApproved.Should().BeFalse(); // Default value
+        }
+
+        [StaFact]
+        public void Constructor_SetsUserApprovedToFalse()
+        {
+            // Arrange & Act
+            var dialog = new PreviewDialog("ITest", "C:\\test.cs", "code");
+
+            // Assert
+            dialog.UserApproved.Should().BeFalse();
+        }
+
+        [StaTheory]
+        [InlineData("ISimpleClass", @"C:\Projects\Test\Interfaces\ISimpleClass.cs")]
+        [InlineData("IUserService", @"C:\Dev\MyApp\Interfaces\IUserService.cs")]
+        [InlineData("IDataRepository", @"C:\Temp\IDataRepository.cs")]
+        public void Constructor_AcceptsDifferentFileNames(string interfaceName, string filePath)
+        {
+            // Arrange & Act
+            var dialog = new PreviewDialog(interfaceName, filePath, "test code");
+
+            // Assert
+            dialog.Should().NotBeNull();
+        }
+
+        [StaFact]
+        public void Constructor_HandlesLongInterfaceCode()
+        {
+            // Arrange
+            var longCode = string.Join("\n", System.Linq.Enumerable.Repeat("// Line of code", 1000));
+
+            // Act
+            var dialog = new PreviewDialog("ILargeInterface", "C:\\test.cs", longCode);
+
+            // Assert
+            dialog.Should().NotBeNull();
+        }
+
+        [StaFact]
+        public void Constructor_HandlesEmptyInterfaceCode()
+        {
+            // Arrange & Act
+            var dialog = new PreviewDialog("IEmpty", "C:\\empty.cs", string.Empty);
+
+            // Assert
+            dialog.Should().NotBeNull();
+        }
+
+        [StaFact]
+        public void Constructor_HandlesSpecialCharactersInCode()
+        {
+            // Arrange
+            var codeWithSpecialChars = @"
+namespace Test
+{
+    public interface ITest
+    {
+        // Comment with special chars: <>&""'
+        string Property { get; set; }
+    }
+}";
+            // Act
+            var dialog = new PreviewDialog("ITest", "C:\\test.cs", codeWithSpecialChars);
+
+            // Assert
+            dialog.Should().NotBeNull();
+        }
+    }
+}
\ No newline at end of file
diff --git a/README.md b/README.md
index 60d5838..10e0a8b 100644
--- a/README.md
+++ b/README.md
@@ -1,18 +1,32 @@
 # Interface Extractor
 
-A Visual Studio 2022 extension that extracts interfaces from C# classes with interactive member selection.
+A Visual Studio 2022 extension that extracts interfaces from C# classes and records with interactive member selection and customizable options.
 
 ## Features
 
 ✨ **Right-click to extract** - Works directly from Solution Explorer context menu  
 ✨ **Interactive selection** - Choose which methods, properties, events, and indexers to include  
-✨ **Smart defaults** - Auto-suggests interface names with "I" prefix  
+✨ **Preview before saving** - Review generated interface before writing to disk  
+✨ **Smart defaults** - Auto-suggests interface names with configurable prefix  
 ✨ **Batch processing** - Handle multiple files at once  
+✨ **Partial class support** - Analyzes all parts of partial classes automatically  
+✨ **Record support** - Works with both classes and records  
+✨ **Implementation stubs** - Generate skeleton implementation classes  
+✨ **Internal members** - Optionally include internal members  
 ✨ **XML documentation** - Preserves XML comments from original members  
 ✨ **Generic support** - Correctly handles generic methods with constraints  
 ✨ **Read-only properties** - Properly detects `{ get; }` vs `{ get; set; }`  
 ✨ **Overwrite protection** - Prompts before replacing existing files  
-✨ **Detailed logging** - Progress tracking in Output Window
+✨ **Detailed logging** - Progress tracking in Output Window  
+✨ **Customizable options** - Configure behavior through Tools → Options  
+✨ **Operator overloads** - Optional support for operator methods  
+✨ **Template system** - Custom headers, sorting, and grouping
+
+### Supported Types
+
+- Public classes (including partial classes)
+- Public records
+- Internal classes/records (optional)
 
 ### Supported Members
 
@@ -20,6 +34,9 @@ A Visual Studio 2022 extension that extracts interfaces from C# classes with int
 - Public properties (with correct accessor detection)
 - Public events
 - Public indexers
+- Public operator overloads (optional - disabled by default)
+- Conversion operators (implicit/explicit)
+- Internal members (optional - disabled by default)
 
 **Note:** Static members and private members are excluded by design.
 
@@ -48,17 +65,77 @@ A Visual Studio 2022 extension that extracts interfaces from C# classes with int
 4. Follow the installation wizard
 5. Restart Visual Studio
 
+## Configuration
+
+Access settings through **Tools → Options → Interface Extractor → General**
+
+### General Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| Interface Folder Name | `Interfaces` | Folder for generated interface files |
+| Interface Prefix | `I` | Suggested prefix for interface names |
+| Namespace Suffix | `.Interfaces` | Appended to original namespace |
+
+### Behavior Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| Automatically Update Class | `true` | Add interface to class declaration |
+| Add Using Directive | `true` | Include using for interface namespace |
+| Warn If No 'I' Prefix | `true` | Show warning if name lacks 'I' prefix |
+| Include Operator Overloads | `false` | Extract operator overloads |
+| Show Preview Before Saving | `true` | Display preview dialog before saving |
+| Include Internal Members | `false` | Include internal members in extraction |
+| Analyze Partial Classes | `true` | Scan all partial files for members |
+
+### Code Generation Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| Generate Implementation Stubs | `false` | Create skeleton implementation class |
+| Implementation Stub Suffix | `Implementation` | Suffix for stub class names |
+
+### Template Settings
+
+| Setting | Default | Description |
+|---------|---------|-------------|
+| Include File Header | `false` | Add header comment to files |
+| File Header Template | See below | Template for file headers |
+| Member Separator Lines | `1` | Blank lines between members (0-3) |
+| Sort Members | `false` | Sort alphabetically by type/name |
+| Group By Member Type | `false` | Group by Properties, Methods, etc. |
+
+**Default File Header Template:**
+```
+// Generated by Interface Extractor on {Date} at {Time}
+// File: {FileName}
+```
+
+Placeholders: `{FileName}`, `{Date}`, `{Time}`
+
 ## Usage
 
 ### Quick Start
 
 1. Right-click any `.cs` file in Solution Explorer
 2. Select **Extract Interface...**
-3. Review/edit the interface name (defaults to `I{ClassName}`)
+3. Review/edit the interface name (defaults based on your prefix setting)
 4. Select members to include
 5. Click **OK**
+6. **Preview the interface (if enabled)**
+7. Click **Save** to create the file
+
+The extension creates an interface file in your configured folder and optionally:
+- Updates the class/record declaration to implement the interface
+- Generates an implementation stub class (if enabled)
 
-The extension creates an `Interfaces` folder, generates the interface file, and adds it to your project.
+### Preview Dialog
+
+When **Show Preview Before Saving** is enabled:
+- Review the complete generated interface code
+- See the exact file path where it will be saved
+- Click **Save** to proceed or **Cancel** to abort
 
 ### Member Selection Dialog
 
@@ -135,73 +212,130 @@ namespace MyProject.Data.Interfaces
 }
 ```
 
-### Generic Methods with Constraints
+### Record Types
 
 **Input:**
 
 ```csharp
-public class Repository
+public record Person
 {
-    public T GetById<T>(int id) where T : class, IEntity, new() { }
+    public string FirstName { get; init; }
+    public string LastName { get; init; }
+    public DateTime BirthDate { get; init; }
+    
+    public int Age => (DateTime.Now - BirthDate).Days / 365;
     
-    public List<T> GetAll<T>() where T : IEntity { }
+    public string GetFullName() => $"{FirstName} {LastName}";
 }
 ```
 
 **Output:**
 
 ```csharp
-public interface IRepository
+public interface IPerson
 {
-    T GetById<T>(int id)
-        where T : class, IEntity, new();
+    string FirstName { get; }
+    
+    string LastName { get; }
+    
+    DateTime BirthDate { get; }
+    
+    int Age { get; }
+    
+    string GetFullName();
+}
+```
+
+**Note:** `init` accessors are converted to `get` for broader compatibility. While `init` is valid in C# 9+ interface declarations, implementing types must also use `init` accessors, which may not always be desirable.
+
+### Partial Classes
+
+**Input - UserService.Part1.cs:**
 
-    List<T> GetAll<T>()
-        where T : IEntity;
+```csharp
+public partial class UserService
+{
+    public User GetUser(int id) { }
+    public void UpdateUser(User user) { }
 }
 ```
 
-### Events and Indexers
+**Input - UserService.Part2.cs:**
 
-**Input:**
+```csharp
+public partial class UserService
+{
+    public List<User> GetAllUsers() { }
+    public void DeleteUser(int id) { }
+}
+```
+
+**Output (combines both files):**
 
 ```csharp
-public class DataCollection
+public interface IUserService
 {
-    public event EventHandler<DataChangedEventArgs> DataChanged;
+    User GetUser(int id);
     
-    public string this[int index]
-    {
-        get { return items[index]; }
-        set { items[index] = value; }
-    }
+    void UpdateUser(User user);
     
-    public int Count { get; }
+    List<User> GetAllUsers();
+    
+    void DeleteUser(int id);
 }
 ```
 
-**Output:**
+### Implementation Stubs
 
+When **Generate Implementation Stubs** is enabled:
+
+**Generated Interface (IBookingData.cs):**
 ```csharp
-public interface IDataCollection
+public interface IBookingData
 {
-    event EventHandler<DataChangedEventArgs> DataChanged;
-
-    string this[int index] { get; set; }
+    Task<Booking> GetBookingAsync(Guid id);
+    string Name { get; set; }
+}
+```
 
-    int Count { get; }
+**Generated Stub (BookingDataImplementation.cs):**
+```csharp
+namespace MyProject.Data
+{
+    public class BookingDataImplementation : IBookingData
+    {
+        public Task<Booking> GetBookingAsync(Guid id)
+        {
+            throw new System.NotImplementedException();
+        }
+        
+        public string Name { get; set; }
+    }
 }
 ```
 
-## Configuration
+### Internal Members
 
-Default settings (modifiable in `Constants.cs`):
+With **Include Internal Members** enabled:
 
-| Setting | Default Value | Description |
-|---------|---------------|-------------|
-| Interface Folder | `Interfaces` | Where interface files are created |
-| Interface Prefix | `I` | Suggested prefix for interface names |
-| Namespace Suffix | `.Interfaces` | Added to original namespace |
+**Input:**
+```csharp
+public class DataService
+{
+    public void PublicMethod() { }
+    internal void InternalMethod() { }
+    private void PrivateMethod() { } // Still excluded
+}
+```
+
+**Output:**
+```csharp
+public interface IDataService
+{
+    void PublicMethod();
+    void InternalMethod(); // Included when option is enabled
+}
+```
 
 ## Troubleshooting
 
@@ -220,16 +354,21 @@ Default settings (modifiable in `Constants.cs`):
 ### Interface not generated correctly
 
 - Check Output Window (View → Output) and select "Interface Extractor"
-- Ensure the class is `public`
+- Ensure the class/record is `public` (or `internal` if that option is enabled)
 - Verify the file contains valid C# syntax
-- Check that at least one public member exists
+- Check that at least one accessible member exists
+
+### Partial class members missing
+
+- Ensure **Analyze Partial Classes** is enabled in options
+- Verify all partial files are in the same project
+- Check Output Window for partial file analysis logs
 
-### Validation errors in dialog
+### Options not taking effect
 
-- Interface names must be valid C# identifiers
-- Cannot use reserved keywords (`class`, `interface`, `void`, etc.)
-- At least one member must be selected
-- Names should start with a letter or underscore
+- Close and reopen Visual Studio after changing options
+- Check Tools → Options → Interface Extractor → General
+- Verify settings were saved (they should persist between sessions)
 
 ## Project Structure
 
@@ -239,9 +378,13 @@ InterfaceExtractor/
 │   └── ExtractInterfaceCommand.cs      # Command handler and orchestration
 ├── Services/
 │   └── InterfaceExtractorService.cs    # Roslyn-based extraction logic
+├── Options/
+│   └── OptionsPage.cs                  # Settings/configuration page
 ├── UI/
 │   ├── ExtractInterfaceDialog.xaml     # Member selection dialog
 │   ├── ExtractInterfaceDialog.xaml.cs
+│   ├── PreviewDialog.xaml              # Interface preview dialog
+│   ├── PreviewDialog.xaml.cs
 │   ├── OverwriteDialog.xaml            # File overwrite confirmation
 │   ├── OverwriteDialog.xaml.cs
 │   └── MemberSelectionItem.cs          # View model for members
@@ -269,47 +412,35 @@ InterfaceExtractor/
 
 ## Known Limitations
 
-- Only processes public, non-static members
-- Does not support operator overloads
-- Partial classes: only analyzes the current file
-- Nested classes: only processes top-level classes
-- No configuration UI (requires source modification)
+- Only processes public and optionally internal members (not private/protected)
+- Nested classes: only processes top-level classes/records
+- Operator overloads in interfaces: Only supported in C# 11+. Generated operator signatures in interfaces require manual addition of `static abstract` keywords, and the containing interface must support static abstract members.
 
-## Roadmap
-
-### Planned for v1.1
-
-- [ ] Options/settings page
-- [ ] Support for operator overloads
-- [ ] Custom interface templates
-- [ ] Automatic class implementation updates
+## Version History
 
-### Planned for v2.0
+See [CHANGELOG.md](CHANGELOG.md) for detailed version history and release notes.
 
-- [ ] Multi-file partial class support
-- [ ] Interface preview before saving
-- [ ] Integration with VS refactoring tools
-- [ ] Support for internal members (optional)
+## License
 
-## Version History
+MIT License
 
-See [CHANGELOG.md](CHANGELOG.md) for detailed version history.
+Copyright (c) 2025 Developer Chizaruu
 
-**v1.0.0** (2025-10-18) - Initial release with full feature set
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 
-## License
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 
-MIT License
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
 ## Contributing
 
 Contributions welcome! Areas for improvement:
 
-- Configuration UI
-- Additional member type support (operators)
-- Advanced namespace handling
-- Template customization system
-- Better integration with VS refactoring
+- Custom template files (.tt or .scriban)
+- Extract interface from multiple classes at once
+- Integration with refactoring tools
+- Performance optimizations
+- Accessibility improvements
 
 ## Support
 
@@ -317,13 +448,16 @@ For issues or questions:
 
 1. Check the **Output Window** (View → Output → "Interface Extractor") for detailed error messages
 2. Review the **Troubleshooting** section above
-3. Verify Visual Studio 2022 and .NET Framework 4.8 compatibility
-4. Create an issue with:
+3. Check **Tools → Options → Interface Extractor** for configuration options
+4. Verify Visual Studio 2022 and .NET Framework 4.8 compatibility
+5. Create an issue with:
    - Visual Studio version
+   - Extension version
    - Steps to reproduce
    - Output Window logs
    - Sample code (if applicable)
+   - Current option settings
 
 ---
 
-**Made with ❤️ for Visual Studio developers**
+**Made with ❤️ for Visual Studio developers**
\ No newline at end of file