@apidiff/core 1.0.0

package/src/rules/param/param-added.ts

@@ -0,0 +1,52 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange, Parameter } from '../../types/index.js';
+
+export class ParamAddedRule extends BaseRule {
+  id = 'PARAM_ADDED';
+  description = 'A new parameter was added';
+  severity = 'info' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'parameters' && fc.fieldPath.length === 2 && fc.changeType === 'added') {
+          const paramId = fc.fieldPath[1];
+          const [paramName, inLoc] = paramId.split(':');
+          
+          // Check if it's a location change
+          const isMoved = ed.fieldChanges.some(c => c.fieldPath[0] === 'parameters' && c.fieldPath.length === 2 && c.changeType === 'removed' && c.fieldPath[1].startsWith(`${paramName}:`));
+          if (isMoved) continue;
+
+          const newParam = fc.newValue as Parameter;
+
+          if (newParam.required) {
+            changes.push(this.makeChange({
+              severity: 'breaking',
+              ruleId: 'PARAM_ADDED_REQUIRED',
+              category: 'parameter',
+              message: `Required parameter '${paramName}' in ${inLoc} was added.`,
+              consequence: 'Existing clients failing to send this new required parameter will receive 400 Bad Request errors.',
+              migration: `Update clients to include the '${paramName}' parameter.`,
+              location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+            }, context));
+          } else {
+            changes.push(this.makeChange({
+              severity: 'info',
+              ruleId: 'PARAM_ADDED',
+              category: 'parameter',
+              message: `Optional parameter '${paramName}' in ${inLoc} was added.`,
+              consequence: 'Clients can optionally provide this new parameter for extended functionality.',
+              migration: 'No immediate action required.',
+              location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+            }, context));
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/param/param-deprecated.ts

@@ -0,0 +1,34 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class ParamDeprecatedRule extends BaseRule {
+  id = 'PARAM_DEPRECATED';
+  description = 'A parameter was marked as deprecated';
+  severity = 'warning' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'parameters' && fc.fieldPath[2] === 'deprecated' && fc.changeType === 'changed') {
+          if (fc.oldValue === false && fc.newValue === true) {
+            const paramId = fc.fieldPath[1];
+            const [paramName, inLoc] = paramId.split(':');
+            changes.push(this.makeChange({
+              severity: 'warning',
+              category: 'parameter',
+              message: `Parameter '${paramName}' in ${inLoc} was deprecated.`,
+              consequence: 'This parameter is slated for future removal.',
+              migration: `Plan to migrate away from using '${paramName}'.`,
+              location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+            }, context));
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/param/param-enum-value-added.ts

@@ -0,0 +1,32 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class ParamEnumValueAddedRule extends BaseRule {
+  id = 'PARAM_ENUM_VALUE_ADDED';
+  description = 'A new allowed enum value was added to a parameter';
+  severity = 'info' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'parameters' && fc.fieldPath[2] === 'schema' && fc.fieldPath.includes('enum') && fc.changeType === 'added') {
+          const paramId = fc.fieldPath[1];
+          const [paramName, inLoc] = paramId.split(':');
+          changes.push(this.makeChange({
+            severity: 'info',
+            category: 'parameter',
+            message: `Enum value '${fc.newValue}' was added to parameter '${paramName}' in ${inLoc}.`,
+            consequence: `Clients can now optionally send '${fc.newValue}' for this parameter.`,
+            migration: 'No immediate action required.',
+            location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+          }, context));
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/param/param-enum-value-removed.ts

@@ -0,0 +1,32 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class ParamEnumValueRemovedRule extends BaseRule {
+  id = 'PARAM_ENUM_VALUE_REMOVED';
+  description = 'An allowed enum value was removed from a parameter';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'parameters' && fc.fieldPath[2] === 'schema' && fc.fieldPath.includes('enum') && fc.changeType === 'removed') {
+          const paramId = fc.fieldPath[1];
+          const [paramName, inLoc] = paramId.split(':');
+          changes.push(this.makeChange({
+            severity: 'breaking',
+            category: 'parameter',
+            message: `Enum value '${fc.oldValue}' was removed from parameter '${paramName}' in ${inLoc}.`,
+            consequence: `Clients sending '${fc.oldValue}' will now receive validation errors.`,
+            migration: `Update clients to use one of the remaining allowed enum values for '${paramName}'.`,
+            location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+          }, context));
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/param/param-location-changed.ts

@@ -0,0 +1,43 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class ParamLocationChangedRule extends BaseRule {
+  id = 'PARAM_LOCATION_CHANGED';
+  description = 'A parameter was moved to a different location (e.g. query to header)';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      const removedParams = new Map<string, string>(); // name -> in
+      const addedParams = new Map<string, string>(); // name -> in
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'parameters' && fc.fieldPath.length === 2) {
+          const paramId = fc.fieldPath[1];
+          const [paramName, inLoc] = paramId.split(':');
+          if (fc.changeType === 'removed') removedParams.set(paramName, inLoc);
+          if (fc.changeType === 'added') addedParams.set(paramName, inLoc);
+        }
+      }
+
+      for (const [name, oldLoc] of removedParams.entries()) {
+        const newLoc = addedParams.get(name);
+        if (newLoc) {
+          changes.push(this.makeChange({
+            severity: 'breaking',
+            category: 'parameter',
+            message: `Parameter '${name}' moved from ${oldLoc} to ${newLoc}.`,
+            consequence: `Clients sending '${name}' in the ${oldLoc} will fail.`,
+            migration: `Update clients to send '${name}' in the ${newLoc} instead.`,
+            location: { path: ed.path, method: ed.method, paramName: name, field: oldLoc }
+          }, context));
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/param/param-removed.ts

@@ -0,0 +1,52 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange, Parameter } from '../../types/index.js';
+
+export class ParamRemovedRule extends BaseRule {
+  id = 'PARAM_REMOVED';
+  description = 'A parameter was removed';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'parameters' && fc.fieldPath.length === 2 && fc.changeType === 'removed') {
+          const paramId = fc.fieldPath[1];
+          const [paramName, inLoc] = paramId.split(':');
+          
+          // Check if it's a location change
+          const isMoved = ed.fieldChanges.some(c => c.fieldPath[0] === 'parameters' && c.fieldPath.length === 2 && c.changeType === 'added' && c.fieldPath[1].startsWith(`${paramName}:`));
+          if (isMoved) continue;
+
+          const oldParam = fc.oldValue as Parameter;
+
+          if (oldParam.required) {
+            changes.push(this.makeChange({
+              severity: 'breaking',
+              ruleId: 'PARAM_REMOVED',
+              category: 'parameter',
+              message: `Required parameter '${paramName}' in ${inLoc} was removed.`,
+              consequence: 'Clients sending this parameter may experience errors or unexpected behavior if the server rejects unknown parameters.',
+              migration: `Update clients to stop sending the '${paramName}' parameter.`,
+              location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+            }, context));
+          } else {
+            changes.push(this.makeChange({
+              severity: 'warning',
+              ruleId: 'PARAM_OPTIONAL_REMOVED',
+              category: 'parameter',
+              message: `Optional parameter '${paramName}' in ${inLoc} was removed.`,
+              consequence: 'Clients sending this parameter will have it ignored, or may receive errors if the server strictly validates inputs.',
+              migration: `Update clients to stop sending the '${paramName}' parameter.`,
+              location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+            }, context));
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/param/param-required-added.ts

@@ -0,0 +1,34 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class ParamRequiredAddedRule extends BaseRule {
+  id = 'PARAM_REQUIRED_FALSE_TO_TRUE';
+  description = 'An optional parameter was made required';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'parameters' && fc.fieldPath[2] === 'required' && fc.changeType === 'changed') {
+          if (fc.oldValue === false && fc.newValue === true) {
+            const paramId = fc.fieldPath[1];
+            const [paramName, inLoc] = paramId.split(':');
+            changes.push(this.makeChange({
+              severity: 'breaking',
+              category: 'parameter',
+              message: `Optional parameter '${paramName}' in ${inLoc} is now required.`,
+              consequence: `Requests missing '${paramName}' will be rejected with a 400 Bad Request error.`,
+              migration: `Update all clients to include '${paramName}' in their requests.`,
+              location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+            }, context));
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/param/param-required-true-to-false.ts

@@ -0,0 +1,34 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class ParamRequiredTrueToFalseRule extends BaseRule {
+  id = 'PARAM_REQUIRED_TRUE_TO_FALSE';
+  description = 'A required parameter was made optional';
+  severity = 'info' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'parameters' && fc.fieldPath[2] === 'required' && fc.changeType === 'changed') {
+          if (fc.oldValue === true && fc.newValue === false) {
+            const paramId = fc.fieldPath[1];
+            const [paramName, inLoc] = paramId.split(':');
+            changes.push(this.makeChange({
+              severity: 'info',
+              category: 'parameter',
+              message: `Required parameter '${paramName}' in ${inLoc} is now optional.`,
+              consequence: 'Clients can omit this parameter in requests.',
+              migration: 'Clients may stop sending this parameter if desired.',
+              location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+            }, context));
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/param/param-type-changed.ts

@@ -0,0 +1,32 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class ParamTypeChangedRule extends BaseRule {
+  id = 'PARAM_TYPE_CHANGED';
+  description = 'The data type of a parameter changed';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'parameters' && fc.fieldPath[2] === 'schema' && fc.fieldPath[3] === 'type' && fc.changeType === 'changed') {
+          const paramId = fc.fieldPath[1];
+          const [paramName, inLoc] = paramId.split(':');
+          changes.push(this.makeChange({
+            severity: 'breaking',
+            category: 'parameter',
+            message: `Parameter '${paramName}' in ${inLoc} changed type from ${fc.oldValue} to ${fc.newValue}.`,
+            consequence: 'Clients sending the old type will receive validation errors.',
+            migration: `Update clients to send the new type (${fc.newValue}) for '${paramName}'.`,
+            location: { path: ed.path, method: ed.method, paramName: paramName, field: inLoc }
+          }, context));
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/request/request-body-added-required.ts

@@ -0,0 +1,33 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange, RequestBody } from '../../types/index.js';
+
+export class RequestBodyAddedRequiredRule extends BaseRule {
+  id = 'REQUEST_BODY_ADDED_REQUIRED';
+  description = 'A required request body was added';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'requestBody' && fc.fieldPath.length === 1 && fc.changeType === 'added') {
+          const body = fc.newValue as RequestBody;
+          if (body.required) {
+            changes.push(this.makeChange({
+              severity: 'breaking',
+              category: 'request-body',
+              message: 'A required request body was added.',
+              consequence: 'Clients not sending a request body will now receive 400 Bad Request errors.',
+              migration: 'Update clients to send the required request body.',
+              location: { path: ed.path, method: ed.method, field: 'requestBody' }
+            }, context));
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/request/request-body-removed.ts

@@ -0,0 +1,30 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class RequestBodyRemovedRule extends BaseRule {
+  id = 'REQUEST_BODY_REMOVED';
+  description = 'A request body was removed';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'requestBody' && fc.fieldPath.length === 1 && fc.changeType === 'removed') {
+          changes.push(this.makeChange({
+            severity: 'breaking',
+            category: 'request-body',
+            message: 'The request body was removed.',
+            consequence: 'Clients sending a request body may experience errors if the server strictly validates requests.',
+            migration: 'Update clients to stop sending a request body.',
+            location: { path: ed.path, method: ed.method, field: 'requestBody' }
+          }, context));
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/request/request-content-type-added.ts

@@ -0,0 +1,31 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class RequestContentTypeAddedRule extends BaseRule {
+  id = 'REQUEST_CONTENT_TYPE_ADDED';
+  description = 'A new content type was added to the request body';
+  severity = 'info' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'requestBody' && fc.fieldPath[1] === 'content' && fc.fieldPath.length === 3 && fc.changeType === 'added') {
+          const mimeType = fc.fieldPath[2];
+          changes.push(this.makeChange({
+            severity: 'info',
+            category: 'request-body',
+            message: `Request content type '${mimeType}' was added.`,
+            consequence: 'Clients can now use this new content type when sending requests.',
+            migration: 'No immediate action required.',
+            location: { path: ed.path, method: ed.method, field: `requestBody.content['${mimeType}']` }
+          }, context));
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/request/request-content-type-removed.ts

@@ -0,0 +1,31 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class RequestContentTypeRemovedRule extends BaseRule {
+  id = 'REQUEST_CONTENT_TYPE_REMOVED';
+  description = 'A content type was removed from the request body';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'requestBody' && fc.fieldPath[1] === 'content' && fc.fieldPath.length === 3 && fc.changeType === 'removed') {
+          const mimeType = fc.fieldPath[2];
+          changes.push(this.makeChange({
+            severity: 'breaking',
+            category: 'request-body',
+            message: `Request content type '${mimeType}' was removed.`,
+            consequence: `Clients sending requests with Content-Type '${mimeType}' will receive 415 Unsupported Media Type errors.`,
+            migration: `Update clients to use a supported content type instead of '${mimeType}'.`,
+            location: { path: ed.path, method: ed.method, field: `requestBody.content['${mimeType}']` }
+          }, context));
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/request/request-field-added-required.ts

@@ -0,0 +1,41 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange, Schema } from '../../types/index.js';
+
+export class RequestFieldAddedRequiredRule extends BaseRule {
+  id = 'REQUEST_FIELD_ADDED_REQUIRED';
+  description = 'A required field was added to the request body';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'requestBody' && fc.changeType === 'added') {
+          const requiredIdx = fc.fieldPath.lastIndexOf('required');
+          if (requiredIdx !== -1 && fc.fieldPath.length === requiredIdx + 2) {
+            const fieldName = fc.fieldPath[requiredIdx + 1];
+            
+            // Check if this property was ALSO added
+            const propsPath = fc.fieldPath.slice(0, requiredIdx).concat(['properties', fieldName]).join('.');
+            const propAdded = ed.fieldChanges.some(c => c.changeType === 'added' && c.fieldPath.join('.') === propsPath);
+            
+            if (propAdded) {
+              changes.push(this.makeChange({
+                severity: 'breaking',
+                category: 'request-body',
+                message: `Required request body field '${fieldName}' was added.`,
+                consequence: `Clients not sending the new '${fieldName}' field will receive validation errors.`,
+                migration: `Update clients to include the '${fieldName}' field in requests.`,
+                location: { path: ed.path, method: ed.method, field: propsPath }
+              }, context));
+            }
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/request/request-field-removed.ts

@@ -0,0 +1,35 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class RequestFieldRemovedRule extends BaseRule {
+  id = 'REQUEST_FIELD_REMOVED';
+  description = 'A field was removed from the request body';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'requestBody' && fc.changeType === 'removed') {
+          // Look for: ['requestBody', 'content', mimeType, 'schema', 'properties', fieldName, ...]
+          const propsIdx = fc.fieldPath.lastIndexOf('properties');
+          if (propsIdx !== -1 && fc.fieldPath.length === propsIdx + 2) {
+            const fieldName = fc.fieldPath[propsIdx + 1];
+            changes.push(this.makeChange({
+              severity: 'breaking',
+              category: 'request-body',
+              message: `Request body field '${fieldName}' was removed.`,
+              consequence: 'Clients sending this field may experience errors if the server strictly validates requests.',
+              migration: `Update clients to stop sending the '${fieldName}' field.`,
+              location: { path: ed.path, method: ed.method, field: fc.fieldPath.join('.') }
+            }, context));
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/request/request-field-type-changed.ts

@@ -0,0 +1,37 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class RequestFieldTypeChangedRule extends BaseRule {
+  id = 'REQUEST_FIELD_TYPE_CHANGED';
+  description = 'The data type of a request body field changed';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'requestBody' && fc.changeType === 'changed') {
+          const typeIdx = fc.fieldPath.lastIndexOf('type');
+          if (typeIdx !== -1 && typeIdx === fc.fieldPath.length - 1) {
+            const propsIdx = fc.fieldPath.lastIndexOf('properties');
+            if (propsIdx !== -1 && typeIdx > propsIdx + 1) {
+              const fieldName = fc.fieldPath[propsIdx + 1];
+              changes.push(this.makeChange({
+                severity: 'breaking',
+                category: 'request-body',
+                message: `Request body field '${fieldName}' changed type from ${fc.oldValue} to ${fc.newValue}.`,
+                consequence: 'Clients sending the old type will receive validation errors.',
+                migration: `Update clients to send the new type (${fc.newValue}) for '${fieldName}'.`,
+                location: { path: ed.path, method: ed.method, field: fc.fieldPath.slice(0, -1).join('.') }
+              }, context));
+            }
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}

package/src/rules/request/request-required-false-to-true.ts

@@ -0,0 +1,56 @@
+import { BaseRule } from '../base.js';
+import type { DiffSet, RuleContext, SemanticChange } from '../../types/index.js';
+
+export class RequestRequiredFalseToTrueRule extends BaseRule {
+  id = 'REQUEST_REQUIRED_FALSE_TO_TRUE';
+  description = 'An optional request body field was made required';
+  severity = 'breaking' as const;
+
+  apply(diff: DiffSet, context: RuleContext): SemanticChange[] {
+    const changes: SemanticChange[] = [];
+    for (const ed of diff.endpointDiffs) {
+      if (ed.type !== 'changed') continue;
+      if (this.isIgnored(ed.path, context)) continue;
+
+      for (const fc of ed.fieldChanges) {
+        if (fc.fieldPath[0] === 'requestBody') {
+          // Check for requestBody.required changing from false to true
+          if (fc.fieldPath.length === 2 && fc.fieldPath[1] === 'required' && fc.changeType === 'changed' && fc.oldValue === false && fc.newValue === true) {
+            changes.push(this.makeChange({
+              severity: 'breaking',
+              category: 'request-body',
+              message: 'The request body was made required.',
+              consequence: 'Clients not sending a request body will now receive validation errors.',
+              migration: 'Update clients to always send a request body.',
+              location: { path: ed.path, method: ed.method, field: 'requestBody.required' }
+            }, context));
+          }
+          
+          // Check for schema field required changing from false to true
+          if (fc.changeType === 'added') {
+            const requiredIdx = fc.fieldPath.lastIndexOf('required');
+            if (requiredIdx !== -1 && fc.fieldPath.length === requiredIdx + 2) {
+              const fieldName = fc.fieldPath[requiredIdx + 1];
+              
+              // Check if this property was ALSO added (if it was, it's covered by REQUEST_FIELD_ADDED_REQUIRED)
+              const propsPath = fc.fieldPath.slice(0, requiredIdx).concat(['properties', fieldName]).join('.');
+              const propAdded = ed.fieldChanges.some(c => c.changeType === 'added' && c.fieldPath.join('.') === propsPath);
+              
+              if (!propAdded) {
+                changes.push(this.makeChange({
+                  severity: 'breaking',
+                  category: 'request-body',
+                  message: `Optional request body field '${fieldName}' is now required.`,
+                  consequence: `Requests missing '${fieldName}' will now be rejected.`,
+                  migration: `Update clients to always include the '${fieldName}' field.`,
+                  location: { path: ed.path, method: ed.method, field: propsPath }
+                }, context));
+              }
+            }
+          }
+        }
+      }
+    }
+    return changes;
+  }
+}