@@ -28,12 +28,105 @@ const (
 	legacyEnvironmentResourceType = "applications.core/environments"
 )
 
+// radiusNamespacePatterns lists namespace prefixes for resource type namespaces that belong to Radius.
+// Resource types matching these prefixes are routed through the Radius control plane, not Azure ARM.
+var radiusNamespacePatterns = []string{
+	"Applications.*",
+	"Radius.*",
+}
+
 // TemplateInspectionResult contains the results of inspecting a Bicep template's resources.
 type TemplateInspectionResult struct {
 	// ContainsEnvironmentResource indicates whether the template contains an environment resource.
 	ContainsEnvironmentResource bool
 }
 
+// ResourceTypeEntry represents a parsed resource type from a compiled Bicep/ARM template.
+type ResourceTypeEntry struct {
+	// FullType is the full type string including API version, e.g. "Radius.Core/applications@2025-08-01-preview".
+	FullType string
+
+	// Type is the resource type without the API version, e.g. "Radius.Core/applications".
+	Type string
+
+	// APIVersion is the API version, e.g. "2025-08-01-preview".
+	APIVersion string
+}
+
+// ExtractResourceTypes extracts all resource types and their API versions from a compiled Bicep/ARM template.
+func ExtractResourceTypes(template map[string]any) []ResourceTypeEntry {
+	if template == nil {
+		return nil
+	}
+
+	resourcesValue, ok := template["resources"]
+	if !ok {
+		return nil
+	}
+
+	resources, ok := resourcesValue.(map[string]any)
+	if !ok {
+		return nil
+	}
+
+	var entries []ResourceTypeEntry
+	for _, resourceValue := range resources {
+		resource, ok := resourceValue.(map[string]any)
+		if !ok {
+			continue
+		}
+
+		resourceType, ok := resource["type"].(string)
+		if !ok || resourceType == "" {
+			continue
+		}
+
+		entry := ResourceTypeEntry{FullType: resourceType}
+		if idx := strings.Index(resourceType, "@"); idx >= 0 {
+			entry.Type = resourceType[:idx]
+			entry.APIVersion = resourceType[idx+1:]
+		} else {
+			entry.Type = resourceType
+		}
+
+		entries = append(entries, entry)
+	}
+
+	return entries
+}
+
+// IsRadiusResourceType returns true if the given resource type belongs to a known Radius namespace.
+// It matches against the patterns in radiusNamespacePatterns (e.g. "Applications.*", "Radius.*")
+// using case-insensitive prefix matching on the namespace portion before the dot and slash.
+func IsRadiusResourceType(resourceType string) bool {
+	lower := strings.ToLower(resourceType)
+	for _, pattern := range radiusNamespacePatterns {
+		// Convert pattern like "Applications.*" to a lowercase prefix like "applications."
+		prefix := strings.ToLower(strings.TrimSuffix(pattern, "*"))
+		if strings.HasPrefix(lower, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
+// HasOnlyRadiusResourceTypes returns true if the template contains at least one resource and
+// all resources belong to known Radius namespaces (none are Azure ARM or other non-Radius types).
+func HasOnlyRadiusResourceTypes(template map[string]any) bool {
+	entries := ExtractResourceTypes(template)
+	if len(entries) == 0 {
+		return false
+	}
+
+	for _, entry := range entries {
+		if !IsRadiusResourceType(entry.Type) {
+			return false
+		}
+	}
+
+	return true
+}
+
 // InspectTemplateResources inspects the compiled Radius Bicep template's resources to find
 // environment resources and determine if any environment resource is present.
 //
 
@@ -302,3 +302,235 @@ func Test_ContainsEnvironmentResource(t *testing.T) {
 	}
 }
 
+func Test_ExtractResourceTypes(t *testing.T) {
+	tests := []struct {
+		name     string
+		template map[string]any
+		expected []ResourceTypeEntry
+	}{
+		{
+			name:     "Nil template",
+			template: nil,
+			expected: nil,
+		},
+		{
+			name:     "Empty template",
+			template: map[string]any{},
+			expected: nil,
+		},
+		{
+			name: "Template with no resources field",
+			template: map[string]any{
+				"parameters": map[string]any{},
+			},
+			expected: nil,
+		},
+		{
+			name: "Template with single resource",
+			template: map[string]any{
+				"resources": map[string]any{
+					"app": map[string]any{
+						"type": "Radius.Core/applications@2025-08-01-preview",
+						"name": "my-app",
+					},
+				},
+			},
+			expected: []ResourceTypeEntry{
+				{
+					FullType:   "Radius.Core/applications@2025-08-01-preview",
+					Type:       "Radius.Core/applications",
+					APIVersion: "2025-08-01-preview",
+				},
+			},
+		},
+		{
+			name: "Template with resource missing API version",
+			template: map[string]any{
+				"resources": map[string]any{
+					"app": map[string]any{
+						"type": "Radius.Core/applications",
+						"name": "my-app",
+					},
+				},
+			},
+			expected: []ResourceTypeEntry{
+				{
+					FullType:   "Radius.Core/applications",
+					Type:       "Radius.Core/applications",
+					APIVersion: "",
+				},
+			},
+		},
+		{
+			name: "Template with invalid resource format",
+			template: map[string]any{
+				"resources": map[string]any{
+					"app": "not a map",
+				},
+			},
+			expected: nil,
+		},
+		{
+			name: "Template with resource missing type",
+			template: map[string]any{
+				"resources": map[string]any{
+					"app": map[string]any{
+						"name": "my-app",
+					},
+				},
+			},
+			expected: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := ExtractResourceTypes(tt.template)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func Test_IsRadiusResourceType(t *testing.T) {
+	tests := []struct {
+		name         string
+		resourceType string
+		expected     bool
+	}{
+		{
+			name:         "Applications.Core type",
+			resourceType: "Applications.Core/applications",
+			expected:     true,
+		},
+		{
+			name:         "Radius.Core type",
+			resourceType: "Radius.Core/environments",
+			expected:     true,
+		},
+		{
+			name:         "Applications.Dapr type",
+			resourceType: "Applications.Dapr/pubSubBrokers",
+			expected:     true,
+		},
+		{
+			name:         "Applications wildcard namespace",
+			resourceType: "Applications.Networking/gateways",
+			expected:     true,
+		},
+		{
+			name:         "Applications.Datastores type",
+			resourceType: "Applications.Datastores/redisCaches",
+			expected:     true,
+		},
+		{
+			name:         "Applications.Messaging type",
+			resourceType: "Applications.Messaging/rabbitMQQueues",
+			expected:     true,
+		},
+		{
+			name:         "Case insensitive match",
+			resourceType: "applications.core/containers",
+			expected:     true,
+		},
+		{
+			name:         "Azure type",
+			resourceType: "Microsoft.Storage/storageAccounts",
+			expected:     false,
+		},
+		{
+			name:         "AWS type",
+			resourceType: "AWS.S3/Bucket",
+			expected:     false,
+		},
+		{
+			name:         "Empty string",
+			resourceType: "",
+			expected:     false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := IsRadiusResourceType(tt.resourceType)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}
+
+func Test_HasOnlyRadiusResourceTypes(t *testing.T) {
+	tests := []struct {
+		name     string
+		template map[string]any
+		expected bool
+	}{
+		{
+			name:     "Nil template",
+			template: nil,
+			expected: false,
+		},
+		{
+			name: "Empty resources",
+			template: map[string]any{
+				"resources": map[string]any{},
+			},
+			expected: false,
+		},
+		{
+			name: "Only Radius types",
+			template: map[string]any{
+				"resources": map[string]any{
+					"app": map[string]any{
+						"type": "Radius.Core/applications@2025-08-01-preview",
+					},
+					"env": map[string]any{
+						"type": "Applications.Core/environments@2023-10-01-preview",
+					},
+				},
+			},
+			expected: true,
+		},
+		{
+			name: "Mixed Radius and Azure types",
+			template: map[string]any{
+				"resources": map[string]any{
+					"app": map[string]any{
+						"type": "Applications.Core/applications@2023-10-01-preview",
+					},
+					"storage": map[string]any{
+						"type": "Microsoft.Storage/storageAccounts@2021-01-01",
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "Only Azure types",
+			template: map[string]any{
+				"resources": map[string]any{
+					"storage": map[string]any{
+						"type": "Microsoft.Storage/storageAccounts@2021-01-01",
+					},
+				},
+			},
+			expected: false,
+		},
+		{
+			name: "Radius type with wrong API version",
+			template: map[string]any{
+				"resources": map[string]any{
+					"app": map[string]any{
+						"type": "Radius.Core/applications@2023-10-01-preview",
+					},
+				},
+			},
+			expected: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := HasOnlyRadiusResourceTypes(tt.template)
+			require.Equal(t, tt.expected, result)
+		})
+	}
+}