diff --git a/bin/validate-json-schema.js b/bin/validate-json-schema.js
index 9a7084a4..11647213 100755
--- a/bin/validate-json-schema.js
+++ b/bin/validate-json-schema.js
@@ -30,6 +30,226 @@ const ajv = new Ajv( {
 } );
 addFormats( ajv );
 
+/**
+ * Fetches the full schema from URL.
+ *
+ * @param {string} schemaUrl The schema URL.
+ * @return {Promise<Object>} The schema object.
+ */
+async function fetchSchema( schemaUrl ) {
+	const response = await fetch( schemaUrl );
+	if ( ! response.ok ) {
+		throw new Error( `Failed to fetch schema from ${ schemaUrl }` );
+	}
+	return await response.json();
+}
+
+/**
+ * Resolves $ref in schema to get the actual definition.
+ *
+ * @param {string} ref        The $ref string.
+ * @param {Object} rootSchema The root schema object.
+ * @return {Object|null} The resolved schema definition.
+ */
+function resolveRef( ref, rootSchema ) {
+	if ( ! ref || ! ref.startsWith( '#/' ) ) {
+		return null;
+	}
+
+	const pathParts = ref.substring( 2 ).split( '/' );
+	let current = rootSchema;
+
+	for ( const part of pathParts ) {
+		if ( ! current || ! current[ part ] ) {
+			return null;
+		}
+		current = current[ part ];
+	}
+
+	return current;
+}
+
+/**
+ * Finds the matching oneOf/anyOf schema based on data.
+ *
+ * @param {Array}  schemas    Array of possible schemas.
+ * @param {*}      data       The data to match against.
+ * @param {Object} rootSchema Root schema for resolving refs.
+ * @return {Object|null} The matched schema.
+ */
+function findMatchingSchema( schemas, data, rootSchema ) {
+	if ( ! Array.isArray( schemas ) || ! data || typeof data !== 'object' ) {
+		return null;
+	}
+
+	// Try to find a match using discriminator (step property)
+	for ( const schema of schemas ) {
+		let resolvedSchema = schema;
+		if ( schema.$ref ) {
+			resolvedSchema = resolveRef( schema.$ref, rootSchema );
+		}
+
+		if ( ! resolvedSchema ) {
+			continue;
+		}
+
+		// Check if this schema matches based on discriminator
+		if ( resolvedSchema.properties ) {
+			// Look for const values that match data
+			let matches = true;
+			for ( const [ key, propSchema ] of Object.entries(
+				resolvedSchema.properties
+			) ) {
+				if (
+					propSchema.const !== undefined &&
+					data[ key ] !== undefined
+				) {
+					if ( propSchema.const !== data[ key ] ) {
+						matches = false;
+						break;
+					}
+				}
+			}
+			if ( matches ) {
+				return resolvedSchema;
+			}
+		}
+	}
+
+	return schemas[ 0 ] || null;
+}
+
+/**
+ * Fully resolves a schema, including nested oneOf/anyOf.
+ *
+ * @param {Object} schema     The schema to resolve.
+ * @param {Object} data       The data to match against (for oneOf/anyOf).
+ * @param {Object} rootSchema Root schema for $ref resolution.
+ * @return {Object|null} Fully resolved schema.
+ */
+function fullyResolveSchema( schema, data, rootSchema ) {
+	if ( ! schema ) {
+		return null;
+	}
+
+	let current = schema;
+
+	// Resolve $ref
+	if ( current.$ref ) {
+		current = resolveRef( current.$ref, rootSchema );
+		if ( ! current ) {
+			return null;
+		}
+	}
+
+	// If this schema has oneOf/anyOf, we need to match and resolve again
+	if ( current.oneOf && data ) {
+		const matched = findMatchingSchema( current.oneOf, data, rootSchema );
+		if ( matched ) {
+			// Recursively resolve the matched schema
+			return fullyResolveSchema( matched, data, rootSchema );
+		}
+	} else if ( current.anyOf && data ) {
+		const matched = findMatchingSchema( current.anyOf, data, rootSchema );
+		if ( matched ) {
+			// Recursively resolve the matched schema
+			return fullyResolveSchema( matched, data, rootSchema );
+		}
+	}
+
+	return current;
+}
+
+/**
+ * Recursively validates deprecated properties.
+ *
+ * @param {Object} schema     Current schema.
+ * @param {*}      data       Current data.
+ * @param {Object} rootSchema Root schema for $ref resolution.
+ * @param {string} path       Current path for error reporting.
+ * @return {Array} Array of deprecation warnings.
+ */
+function validateDeprecated( schema, data, rootSchema, path = '' ) {
+	const warnings = [];
+
+	if ( ! schema || typeof schema !== 'object' ) {
+		return warnings;
+	}
+
+	// Resolve $ref
+	let currentSchema = schema;
+	if ( schema.$ref ) {
+		currentSchema = resolveRef( schema.$ref, rootSchema );
+		if ( ! currentSchema ) {
+			return warnings;
+		}
+	}
+
+	// Handle arrays
+	if ( Array.isArray( data ) ) {
+		if ( currentSchema.items ) {
+			data.forEach( ( item, index ) => {
+				const itemPath = `${ path }[${ index }]`;
+
+				// Fully resolve the item schema
+				const itemSchema = fullyResolveSchema(
+					currentSchema.items,
+					item,
+					rootSchema
+				);
+
+				if ( itemSchema ) {
+					warnings.push(
+						...validateDeprecated(
+							itemSchema,
+							item,
+							rootSchema,
+							itemPath
+						)
+					);
+				}
+			} );
+		}
+		return warnings;
+	}
+
+	// Handle objects
+	if ( data && typeof data === 'object' ) {
+		// Check each property
+		if ( currentSchema.properties ) {
+			for ( const [ key, value ] of Object.entries( data ) ) {
+				const propSchema = currentSchema.properties[ key ];
+				if ( ! propSchema ) {
+					continue;
+				}
+
+				const propPath = path ? `${ path }.${ key }` : key;
+
+				// Check if this property itself is deprecated
+				if ( propSchema.deprecated ) {
+					const msg =
+						typeof propSchema.deprecated === 'string'
+							? propSchema.deprecated
+							: 'This property is deprecated';
+					warnings.push( { path: propPath, message: msg } );
+				}
+
+				// Recursively check the value
+				warnings.push(
+					...validateDeprecated(
+						propSchema,
+						value,
+						rootSchema,
+						propPath
+					)
+				);
+			}
+		}
+	}
+
+	return warnings;
+}
+
 /**
  * Validates a JSON file against its schema.
  *
@@ -61,6 +281,7 @@ async function validateFile( filePath ) {
 	console.log( `Validating ${ filePath } against schema: ${ data.$schema }` );
 
 	try {
+		// Standard validation
 		const validate = await ajv.compileAsync( { $ref: data.$schema } );
 		const valid = validate( data );
 
@@ -71,6 +292,30 @@ async function validateFile( filePath ) {
 			} );
 			process.exit( 1 );
 		}
+
+		// Fetch the full schema for deprecation checking
+		const fullSchema = await fetchSchema( data.$schema );
+
+		// Resolve root schema if it has $ref
+		let rootSchema = fullSchema;
+		if ( fullSchema.$ref ) {
+			rootSchema = resolveRef( fullSchema.$ref, fullSchema );
+		}
+
+		if ( ! rootSchema ) {
+			console.error( 'Failed to resolve root schema' );
+			return;
+		}
+
+		const deprecations = validateDeprecated( rootSchema, data, fullSchema );
+
+		if ( deprecations.length > 0 ) {
+			console.error( `\nDeprecation errors in ${ filePath }:` );
+			deprecations.forEach( ( warning ) => {
+				console.error( `- /${ warning.path }: ${ warning.message }` );
+			} );
+			process.exit( 1 );
+		}
 	} catch ( error ) {
 		console.error( `Error validating ${ filePath }: ${ error.message }` );
 		process.exit( 1 );