fix: callback reference proxy implementation

baywet · baywet · commit 2cbb0fa352ec · 2025-01-24T13:49:34.000-05:00
diff --git a/src/Microsoft.OpenApi.Hidi/StatsVisitor.cs b/src/Microsoft.OpenApi.Hidi/StatsVisitor.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Models.Interfaces;
 using Microsoft.OpenApi.Services;
 
 namespace Microsoft.OpenApi.Hidi
@@ -68,7 +69,7 @@ public override void Visit(OpenApiLink link)
 
         public int CallbackCount { get; set; }
 
-        public override void Visit(OpenApiCallback callback)
+        public override void Visit(IOpenApiCallback callback)
         {
             CallbackCount++;
         }
diff --git a/src/Microsoft.OpenApi.Workbench/StatsVisitor.cs b/src/Microsoft.OpenApi.Workbench/StatsVisitor.cs
@@ -4,6 +4,7 @@
 using System;
 using System.Collections.Generic;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Models.Interfaces;
 using Microsoft.OpenApi.Services;
 
 namespace Microsoft.OpenApi.Workbench
@@ -68,7 +69,7 @@ public override void Visit(OpenApiLink link)
 
         public int CallbackCount { get; set; }
 
-        public override void Visit(OpenApiCallback callback)
+        public override void Visit(IOpenApiCallback callback)
         {
             CallbackCount++;
         }
diff --git a/src/Microsoft.OpenApi/Models/Interfaces/IOpenApiCallback.cs b/src/Microsoft.OpenApi/Models/Interfaces/IOpenApiCallback.cs
@@ -0,0 +1,18 @@
+
+using System.Collections.Generic;
+using Microsoft.OpenApi.Expressions;
+using Microsoft.OpenApi.Interfaces;
+
+namespace Microsoft.OpenApi.Models.Interfaces;
+
+/// <summary>
+/// Defines the base properties for the callback object.
+/// This interface is provided for type assertions but should not be implemented by package consumers beyond automatic mocking.
+/// </summary>
+public interface IOpenApiCallback : IOpenApiSerializable, IOpenApiReadOnlyExtensible
+{
+    /// <summary>
+    /// A Path Item Object used to define a callback request and expected responses.
+    /// </summary>
+    public Dictionary<RuntimeExpression, OpenApiPathItem> PathItems { get; }
+}
diff --git a/src/Microsoft.OpenApi/Models/OpenApiCallback.cs b/src/Microsoft.OpenApi/Models/OpenApiCallback.cs
@@ -5,35 +5,25 @@
 using System.Collections.Generic;
 using Microsoft.OpenApi.Expressions;
 using Microsoft.OpenApi.Interfaces;
+using Microsoft.OpenApi.Models.Interfaces;
 using Microsoft.OpenApi.Writers;
 
 namespace Microsoft.OpenApi.Models
 {
     /// <summary>
     /// Callback Object: A map of possible out-of band callbacks related to the parent operation.
     /// </summary>
-    public class OpenApiCallback : IOpenApiReferenceable, IOpenApiExtensible
+    public class OpenApiCallback : IOpenApiReferenceable, IOpenApiExtensible, IOpenApiCallback
     {
-        /// <summary>
-        /// A Path Item Object used to define a callback request and expected responses.
-        /// </summary>
-        public virtual Dictionary<RuntimeExpression, OpenApiPathItem> PathItems { get; set; }
-            = new();
+        /// <inheritdoc/>
+        public Dictionary<RuntimeExpression, OpenApiPathItem> PathItems { get; set; }
+            = [];
 
-        /// <summary>
-        /// Indicates if object is populated with data or is just a reference to the data
-        /// </summary>
-        public virtual bool UnresolvedReference { get; set; }
-
-        /// <summary>
-        /// Reference pointer.
-        /// </summary>
-        public OpenApiReference Reference { get; set; }
 
         /// <summary>
         /// This object MAY be extended with Specification Extensions.
         /// </summary>
-        public virtual IDictionary<string, IOpenApiExtension> Extensions { get; set; } = new Dictionary<string, IOpenApiExtension>();
+        public IDictionary<string, IOpenApiExtension> Extensions { get; set; } = new Dictionary<string, IOpenApiExtension>();
 
         /// <summary>
         /// Parameter-less constructor
@@ -43,11 +33,9 @@ public OpenApiCallback() { }
         /// <summary>
         /// Initializes a copy of an <see cref="OpenApiCallback"/> object
         /// </summary>
-        public OpenApiCallback(OpenApiCallback callback)
+        public OpenApiCallback(IOpenApiCallback callback)
         {
             PathItems = callback?.PathItems != null ? new(callback?.PathItems) : null;
-            UnresolvedReference = callback?.UnresolvedReference ?? UnresolvedReference;
-            Reference = callback?.Reference != null ? new(callback?.Reference) : null;
             Extensions = callback?.Extensions != null ? new Dictionary<string, IOpenApiExtension>(callback.Extensions) : null;
         }
 
@@ -71,15 +59,15 @@ public void AddPathItem(RuntimeExpression expression, OpenApiPathItem pathItem)
         /// </summary>
         /// <param name="writer"></param>
         /// <exception cref="System.NotImplementedException"></exception>
-        public virtual void SerializeAsV31(IOpenApiWriter writer)
+        public void SerializeAsV31(IOpenApiWriter writer)
         {
             SerializeInternal(writer, OpenApiSpecVersion.OpenApi3_1, (writer, element) => element.SerializeAsV31(writer));
         }
 
         /// <summary>
         /// Serialize <see cref="OpenApiCallback"/> to Open Api v3.0
         /// </summary>
-        public virtual void SerializeAsV3(IOpenApiWriter writer)
+        public void SerializeAsV3(IOpenApiWriter writer)
         {
             SerializeInternal(writer, OpenApiSpecVersion.OpenApi3_0, (writer, element) => element.SerializeAsV3(writer));
         }
diff --git a/src/Microsoft.OpenApi/Models/OpenApiComponents.cs b/src/Microsoft.OpenApi/Models/OpenApiComponents.cs
@@ -63,7 +63,7 @@ public class OpenApiComponents : IOpenApiSerializable, IOpenApiExtensible
         /// <summary>
         /// An object to hold reusable <see cref="OpenApiCallback"/> Objects.
         /// </summary>
-        public virtual IDictionary<string, OpenApiCallback>? Callbacks { get; set; } = new Dictionary<string, OpenApiCallback>();
+        public virtual IDictionary<string, IOpenApiCallback>? Callbacks { get; set; } = new Dictionary<string, IOpenApiCallback>();
 
         /// <summary>
         /// An object to hold reusable <see cref="OpenApiPathItem"/> Object.
@@ -93,7 +93,7 @@ public OpenApiComponents(OpenApiComponents? components)
             Headers = components?.Headers != null ? new Dictionary<string, OpenApiHeader>(components.Headers) : null;
             SecuritySchemes = components?.SecuritySchemes != null ? new Dictionary<string, OpenApiSecurityScheme>(components.SecuritySchemes) : null;
             Links = components?.Links != null ? new Dictionary<string, OpenApiLink>(components.Links) : null;
-            Callbacks = components?.Callbacks != null ? new Dictionary<string, OpenApiCallback>(components.Callbacks) : null;
+            Callbacks = components?.Callbacks != null ? new Dictionary<string, IOpenApiCallback>(components.Callbacks) : null;
             PathItems = components?.PathItems != null ? new Dictionary<string, OpenApiPathItem>(components.PathItems) : null;
             Extensions = components?.Extensions != null ? new Dictionary<string, IOpenApiExtension>(components.Extensions) : null;
         }
diff --git a/src/Microsoft.OpenApi/Models/OpenApiDocument.cs b/src/Microsoft.OpenApi/Models/OpenApiDocument.cs
@@ -608,7 +608,7 @@ public bool AddComponent<T>(string id, T componentToRegister)
                     Components.Links.Add(id, openApiLink);
                     break;
                 case OpenApiCallback openApiCallback:
-                    Components.Callbacks ??= new Dictionary<string, OpenApiCallback>();
+                    Components.Callbacks ??= new Dictionary<string, IOpenApiCallback>();
                     Components.Callbacks.Add(id, openApiCallback);
                     break;
                 case OpenApiPathItem openApiPathItem:
diff --git a/src/Microsoft.OpenApi/Models/OpenApiOperation.cs b/src/Microsoft.OpenApi/Models/OpenApiOperation.cs
@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using Microsoft.OpenApi.Interfaces;
+using Microsoft.OpenApi.Models.Interfaces;
 using Microsoft.OpenApi.Models.References;
 using Microsoft.OpenApi.Writers;
 
@@ -80,7 +81,7 @@ public class OpenApiOperation : IOpenApiSerializable, IOpenApiExtensible, IOpenA
         /// The key value used to identify the callback object is an expression, evaluated at runtime,
         /// that identifies a URL to use for the callback operation.
         /// </summary>
-        public IDictionary<string, OpenApiCallback>? Callbacks { get; set; } = new Dictionary<string, OpenApiCallback>();
+        public IDictionary<string, IOpenApiCallback>? Callbacks { get; set; } = new Dictionary<string, IOpenApiCallback>();
 
         /// <summary>
         /// Declares this operation to be deprecated. Consumers SHOULD refrain from usage of the declared operation.
@@ -129,7 +130,7 @@ public OpenApiOperation(OpenApiOperation? operation)
             Parameters = operation?.Parameters != null ? new List<OpenApiParameter>(operation.Parameters) : null;
             RequestBody = operation?.RequestBody != null ? new(operation?.RequestBody) : null;
             Responses = operation?.Responses != null ? new(operation?.Responses) : null;
-            Callbacks = operation?.Callbacks != null ? new Dictionary<string, OpenApiCallback>(operation.Callbacks) : null;
+            Callbacks = operation?.Callbacks != null ? new Dictionary<string, IOpenApiCallback>(operation.Callbacks) : null;
             Deprecated = operation?.Deprecated ?? Deprecated;
             Security = operation?.Security != null ? new List<OpenApiSecurityRequirement>(operation.Security) : null;
             Servers = operation?.Servers != null ? new List<OpenApiServer>(operation.Servers) : null;
diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiCallbackReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiCallbackReference.cs
@@ -5,18 +5,23 @@
 using System.Collections.Generic;
 using Microsoft.OpenApi.Expressions;
 using Microsoft.OpenApi.Interfaces;
+using Microsoft.OpenApi.Models.Interfaces;
 using Microsoft.OpenApi.Writers;
 
 namespace Microsoft.OpenApi.Models.References
 {
     /// <summary>
     /// Callback Object Reference: A reference to a map of possible out-of band callbacks related to the parent operation.
     /// </summary>
-    public class OpenApiCallbackReference : OpenApiCallback, IOpenApiReferenceHolder<OpenApiCallback>
+    public class OpenApiCallbackReference : IOpenApiCallback, IOpenApiReferenceHolder<OpenApiCallback, IOpenApiCallback>
     {
 #nullable enable
         internal OpenApiCallback _target;
-        private readonly OpenApiReference _reference;
+        /// <inheritdoc/>
+        public OpenApiReference Reference { get; set; }
+
+        /// <inheritdoc/>
+        public bool UnresolvedReference { get; set; }
 
         /// <summary>
         /// Gets the target callback.
@@ -29,7 +34,7 @@ public OpenApiCallback Target
         {
             get
             {
-                _target ??= Reference.HostDocument.ResolveReferenceTo<OpenApiCallback>(_reference);
+                _target ??= Reference.HostDocument.ResolveReferenceTo<OpenApiCallback>(Reference);
                 return _target;
             }
         }
@@ -48,41 +53,49 @@ public OpenApiCallbackReference(string referenceId, OpenApiDocument hostDocument
         {
             Utils.CheckArgumentNullOrEmpty(referenceId);
 
-            _reference = new OpenApiReference()
+            Reference = new OpenApiReference()
             {                
                 Id = referenceId,
                 HostDocument = hostDocument,
                 Type = ReferenceType.Callback,
                 ExternalResource = externalResource
             };
+        }
 
-            Reference = _reference;
+        /// <summary>
+        /// Copy constructor
+        /// </summary>
+        /// <param name="callback">The callback reference to copy</param>
+        public OpenApiCallbackReference(OpenApiCallbackReference callback)
+        {
+            Utils.CheckArgumentNull(callback);
+            Reference = callback?.Reference != null ? new(callback.Reference) : null;
+            UnresolvedReference = callback?.UnresolvedReference ?? false;
         }
 
         internal OpenApiCallbackReference(OpenApiCallback target, string referenceId)
         {
             _target = target;
 
-            _reference = new OpenApiReference()
+            Reference = new OpenApiReference()
             {
                 Id = referenceId,
                 Type = ReferenceType.Callback,
             };
         }
 
         /// <inheritdoc/>
-        public override Dictionary<RuntimeExpression, OpenApiPathItem> PathItems { get => Target.PathItems; set => Target.PathItems = value; }
+        public Dictionary<RuntimeExpression, OpenApiPathItem> PathItems { get => Target.PathItems; }
 
         /// <inheritdoc/>
-        public override IDictionary<string, IOpenApiExtension> Extensions { get => Target.Extensions; set => Target.Extensions = value; }
+        public IDictionary<string, IOpenApiExtension> Extensions { get => Target.Extensions; }
 
         /// <inheritdoc/>
-        public override void SerializeAsV3(IOpenApiWriter writer)
+        public void SerializeAsV3(IOpenApiWriter writer)
         {
-            if (!writer.GetSettings().ShouldInlineReference(_reference))
+            if (!writer.GetSettings().ShouldInlineReference(Reference))
             {
-                _reference.SerializeAsV3(writer);
-                return;
+                Reference.SerializeAsV3(writer);
             }
             else
             {
@@ -91,19 +104,33 @@ public override void SerializeAsV3(IOpenApiWriter writer)
         }
 
         /// <inheritdoc/>
-        public override void SerializeAsV31(IOpenApiWriter writer)
+        public void SerializeAsV31(IOpenApiWriter writer)
         {
-            if (!writer.GetSettings().ShouldInlineReference(_reference))
+            if (!writer.GetSettings().ShouldInlineReference(Reference))
             {
-                _reference.SerializeAsV31(writer);
-                return;
+                Reference.SerializeAsV31(writer);
             }
             else
             {
                 SerializeInternal(writer, (writer, element) => element.SerializeAsV31(writer));
             }
         }
 
+        /// <inheritdoc/>
+        public IOpenApiCallback CopyReferenceAsTargetElementWithOverrides(IOpenApiCallback openApiExample)
+        {
+            // the copy here is never called since callbacks do not have any overridable fields.
+            // if the spec evolves to include overridable fields for callbacks, the serialize methods will need to call this copy method.
+            return openApiExample is OpenApiCallback ? new OpenApiCallback(this) : openApiExample;
+        }
+
+        /// <inheritdoc/>
+        public void SerializeAsV2(IOpenApiWriter writer)
+        {
+            // examples components are not supported in OAS 2.0
+            Reference.SerializeAsV2(writer);
+        }
+
         /// <inheritdoc/>
         private void SerializeInternal(IOpenApiWriter writer,
             Action<IOpenApiWriter, IOpenApiReferenceable> action)
diff --git a/src/Microsoft.OpenApi/Models/References/OpenApiExampleReference.cs b/src/Microsoft.OpenApi/Models/References/OpenApiExampleReference.cs
@@ -19,7 +19,7 @@ public class OpenApiExampleReference : IOpenApiReferenceHolder<OpenApiExample, I
         public OpenApiReference Reference { get; set; }
 
         /// <inheritdoc/>
-        public bool UnresolvedReference { get; set; } = false;
+        public bool UnresolvedReference { get; set; }
         internal OpenApiExample _target;
 
         /// <summary>
@@ -68,7 +68,7 @@ public OpenApiExampleReference(OpenApiExampleReference example)
         {
             Utils.CheckArgumentNull(example);
             Reference = example?.Reference != null ? new(example.Reference) : null;
-            UnresolvedReference = example?.UnresolvedReference ?? UnresolvedReference;
+            UnresolvedReference = example?.UnresolvedReference ?? false;
             //no need to copy summary and description as if they are not overridden, they will be fetched from the target
             //if they are, the reference copy will handle it
         }
diff --git a/src/Microsoft.OpenApi/Reader/V3/OpenApiCallbackDeserializer.cs b/src/Microsoft.OpenApi/Reader/V3/OpenApiCallbackDeserializer.cs
@@ -4,6 +4,7 @@
 using Microsoft.OpenApi.Expressions;
 using Microsoft.OpenApi.Extensions;
 using Microsoft.OpenApi.Models;
+using Microsoft.OpenApi.Models.Interfaces;
 using Microsoft.OpenApi.Models.References;
 using Microsoft.OpenApi.Reader.ParseNodes;
 
@@ -24,7 +25,7 @@ internal static partial class OpenApiV3Deserializer
                 {s => s.StartsWith("x-"), (o, p, n, _) => o.AddExtension(p, LoadExtension(p,n))},
             };
 
-        public static OpenApiCallback LoadCallback(ParseNode node, OpenApiDocument hostDocument)
+        public static IOpenApiCallback LoadCallback(ParseNode node, OpenApiDocument hostDocument)
         {
             var mapNode = node.CheckMapNode("callback");
 
diff --git a/src/Microsoft.OpenApi/Reader/V31/OpenApiCallbackDeserializer.cs b/src/Microsoft.OpenApi/Reader/V31/OpenApiCallbackDeserializer.cs
@@ -4,6 +4,7 @@
 using Microsoft.OpenApi.Models;
 using Microsoft.OpenApi.Reader.ParseNodes;
 using Microsoft.OpenApi.Models.References;
+using Microsoft.OpenApi.Models.Interfaces;
 
 namespace Microsoft.OpenApi.Reader.V31
 {
@@ -23,7 +24,7 @@ internal static partial class OpenApiV31Deserializer
             {s => s.StartsWith("x-", StringComparison.OrdinalIgnoreCase), (o, p, n, _) => o.AddExtension(p, LoadExtension(p,n))},
             };
 
-        public static OpenApiCallback LoadCallback(ParseNode node, OpenApiDocument hostDocument)
+        public static IOpenApiCallback LoadCallback(ParseNode node, OpenApiDocument hostDocument)
         {
             var mapNode = node.CheckMapNode("callback");
 
diff --git a/src/Microsoft.OpenApi/Services/CopyReferences.cs b/src/Microsoft.OpenApi/Services/CopyReferences.cs
@@ -136,9 +136,9 @@ private void AddCallbackToComponents(OpenApiCallback callback, string referenceI
     {
         EnsureComponentsExist();
         EnsureCallbacksExist();
-        if (!Components.Callbacks.ContainsKey(referenceId ?? callback.Reference.Id))
+        if (!Components.Callbacks.ContainsKey(referenceId))
         {
-            Components.Callbacks.Add(referenceId ?? callback.Reference.Id, callback);
+            Components.Callbacks.Add(referenceId, callback);
         }
     }
     private void AddHeaderToComponents(OpenApiHeader header, string referenceId = null)
@@ -230,7 +230,7 @@ private void EnsureHeadersExist()
 
     private void EnsureCallbacksExist()
     {
-        _target.Components.Callbacks ??= new Dictionary<string, OpenApiCallback>();
+        _target.Components.Callbacks ??= new Dictionary<string, IOpenApiCallback>();
     }
 
     private void EnsureLinksExist()
diff --git a/src/Microsoft.OpenApi/Services/OpenApiVisitorBase.cs b/src/Microsoft.OpenApi/Services/OpenApiVisitorBase.cs
diff --git a/src/Microsoft.OpenApi/Services/OpenApiWalker.cs b/src/Microsoft.OpenApi/Services/OpenApiWalker.cs
diff --git a/src/Microsoft.OpenApi/Validations/OpenApiValidator.cs b/src/Microsoft.OpenApi/Validations/OpenApiValidator.cs
diff --git a/test/Microsoft.OpenApi.Readers.Tests/V3Tests/OpenApiCallbackTests.cs b/test/Microsoft.OpenApi.Readers.Tests/V3Tests/OpenApiCallbackTests.cs
diff --git a/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt b/test/Microsoft.OpenApi.Tests/PublicApi/PublicApi.approved.txt
diff --git a/test/Microsoft.OpenApi.Tests/Visitors/InheritanceTests.cs b/test/Microsoft.OpenApi.Tests/Visitors/InheritanceTests.cs

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using System;`
`5`	`5`	`using System.Collections.Generic;`
`6`	`6`	`using Microsoft.OpenApi.Models;`
	`7`	`+using Microsoft.OpenApi.Models.Interfaces;`
`7`	`8`	`using Microsoft.OpenApi.Services;`
`8`	`9`
`9`	`10`	`namespace Microsoft.OpenApi.Hidi`
`@@ -68,7 +69,7 @@ public override void Visit(OpenApiLink link)`
`68`	`69`
`69`	`70`	`public int CallbackCount { get; set; }`
`70`	`71`
`71`		`- public override void Visit(OpenApiCallback callback)`
	`72`	`+ public override void Visit(IOpenApiCallback callback)`
`72`	`73`	`{`
`73`	`74`	`CallbackCount++;`
`74`	`75`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,18 +5,23 @@`
`5`	`5`	`using System.Collections.Generic;`
`6`	`6`	`using Microsoft.OpenApi.Expressions;`
`7`	`7`	`using Microsoft.OpenApi.Interfaces;`
	`8`	`+using Microsoft.OpenApi.Models.Interfaces;`
`8`	`9`	`using Microsoft.OpenApi.Writers;`
`9`	`10`
`10`	`11`	`namespace Microsoft.OpenApi.Models.References`
`11`	`12`	`{`
`12`	`13`	`/// <summary>`
`13`	`14`	`/// Callback Object Reference: A reference to a map of possible out-of band callbacks related to the parent operation.`
`14`	`15`	`/// </summary>`
`15`		`- public class OpenApiCallbackReference : OpenApiCallback, IOpenApiReferenceHolder<OpenApiCallback>`
	`16`	`+ public class OpenApiCallbackReference : IOpenApiCallback, IOpenApiReferenceHolder<OpenApiCallback, IOpenApiCallback>`
`16`	`17`	`{`
`17`	`18`	`#nullable enable`
`18`	`19`	`internal OpenApiCallback _target;`
`19`		`- private readonly OpenApiReference _reference;`
	`20`	`+ /// <inheritdoc/>`
	`21`	`+ public OpenApiReference Reference { get; set; }`
	`22`	`+`
	`23`	`+ /// <inheritdoc/>`
	`24`	`+ public bool UnresolvedReference { get; set; }`
`20`	`25`
`21`	`26`	`/// <summary>`
`22`	`27`	`/// Gets the target callback.`
`@@ -29,7 +34,7 @@ public OpenApiCallback Target`
`29`	`34`	`{`
`30`	`35`	`get`
`31`	`36`	`{`
`32`		`- _target ??= Reference.HostDocument.ResolveReferenceTo<OpenApiCallback>(_reference);`
	`37`	`+ _target ??= Reference.HostDocument.ResolveReferenceTo<OpenApiCallback>(Reference);`
`33`	`38`	`return _target;`
`34`	`39`	`}`
`35`	`40`	`}`
`@@ -48,41 +53,49 @@ public OpenApiCallbackReference(string referenceId, OpenApiDocument hostDocument`
`48`	`53`	`{`
`49`	`54`	`Utils.CheckArgumentNullOrEmpty(referenceId);`
`50`	`55`
`51`		`- _reference = new OpenApiReference()`
	`56`	`+ Reference = new OpenApiReference()`
`52`	`57`	`{`
`53`	`58`	`Id = referenceId,`
`54`	`59`	`HostDocument = hostDocument,`
`55`	`60`	`Type = ReferenceType.Callback,`
`56`	`61`	`ExternalResource = externalResource`
`57`	`62`	`};`
	`63`	`+ }`
`58`	`64`
`59`		`- Reference = _reference;`
	`65`	`+ /// <summary>`
	`66`	`+ /// Copy constructor`
	`67`	`+ /// </summary>`
	`68`	`+ /// <param name="callback">The callback reference to copy</param>`
	`69`	`+ public OpenApiCallbackReference(OpenApiCallbackReference callback)`
	`70`	`+ {`
	`71`	`+ Utils.CheckArgumentNull(callback);`
	`72`	`+ Reference = callback?.Reference != null ? new(callback.Reference) : null;`
	`73`	`+ UnresolvedReference = callback?.UnresolvedReference ?? false;`
`60`	`74`	`}`
`61`	`75`
`62`	`76`	`internal OpenApiCallbackReference(OpenApiCallback target, string referenceId)`
`63`	`77`	`{`
`64`	`78`	`_target = target;`
`65`	`79`
`66`		`- _reference = new OpenApiReference()`
	`80`	`+ Reference = new OpenApiReference()`
`67`	`81`	`{`
`68`	`82`	`Id = referenceId,`
`69`	`83`	`Type = ReferenceType.Callback,`
`70`	`84`	`};`
`71`	`85`	`}`
`72`	`86`
`73`	`87`	`/// <inheritdoc/>`
`74`		`- public override Dictionary<RuntimeExpression, OpenApiPathItem> PathItems { get => Target.PathItems; set => Target.PathItems = value; }`
	`88`	`+ public Dictionary<RuntimeExpression, OpenApiPathItem> PathItems { get => Target.PathItems; }`
`75`	`89`
`76`	`90`	`/// <inheritdoc/>`
`77`		`- public override IDictionary<string, IOpenApiExtension> Extensions { get => Target.Extensions; set => Target.Extensions = value; }`
	`91`	`+ public IDictionary<string, IOpenApiExtension> Extensions { get => Target.Extensions; }`
`78`	`92`
`79`	`93`	`/// <inheritdoc/>`
`80`		`- public override void SerializeAsV3(IOpenApiWriter writer)`
	`94`	`+ public void SerializeAsV3(IOpenApiWriter writer)`
`81`	`95`	`{`
`82`		`- if (!writer.GetSettings().ShouldInlineReference(_reference))`
	`96`	`+ if (!writer.GetSettings().ShouldInlineReference(Reference))`
`83`	`97`	`{`
`84`		`- _reference.SerializeAsV3(writer);`
`85`		`- return;`
	`98`	`+ Reference.SerializeAsV3(writer);`
`86`	`99`	`}`
`87`	`100`	`else`
`88`	`101`	`{`
`@@ -91,19 +104,33 @@ public override void SerializeAsV3(IOpenApiWriter writer)`
`91`	`104`	`}`
`92`	`105`
`93`	`106`	`/// <inheritdoc/>`
`94`		`- public override void SerializeAsV31(IOpenApiWriter writer)`
	`107`	`+ public void SerializeAsV31(IOpenApiWriter writer)`
`95`	`108`	`{`
`96`		`- if (!writer.GetSettings().ShouldInlineReference(_reference))`
	`109`	`+ if (!writer.GetSettings().ShouldInlineReference(Reference))`
`97`	`110`	`{`
`98`		`- _reference.SerializeAsV31(writer);`
`99`		`- return;`
	`111`	`+ Reference.SerializeAsV31(writer);`
`100`	`112`	`}`
`101`	`113`	`else`
`102`	`114`	`{`
`103`	`115`	`SerializeInternal(writer, (writer, element) => element.SerializeAsV31(writer));`
`104`	`116`	`}`
`105`	`117`	`}`
`106`	`118`
	`119`	`+ /// <inheritdoc/>`
	`120`	`+ public IOpenApiCallback CopyReferenceAsTargetElementWithOverrides(IOpenApiCallback openApiExample)`
	`121`	`+ {`
	`122`	`+ // the copy here is never called since callbacks do not have any overridable fields.`
	`123`	`+ // if the spec evolves to include overridable fields for callbacks, the serialize methods will need to call this copy method.`
	`124`	`+ return openApiExample is OpenApiCallback ? new OpenApiCallback(this) : openApiExample;`
	`125`	`+ }`
	`126`	`+`
	`127`	`+ /// <inheritdoc/>`
	`128`	`+ public void SerializeAsV2(IOpenApiWriter writer)`
	`129`	`+ {`
	`130`	`+ // examples components are not supported in OAS 2.0`
	`131`	`+ Reference.SerializeAsV2(writer);`
	`132`	`+ }`
	`133`	`+`
`107`	`134`	`/// <inheritdoc/>`
`108`	`135`	`private void SerializeInternal(IOpenApiWriter writer,`
`109`	`136`	`Action<IOpenApiWriter, IOpenApiReferenceable> action)`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`using Microsoft.OpenApi.Models;`
`5`	`5`	`using Microsoft.OpenApi.Reader.ParseNodes;`
`6`	`6`	`using Microsoft.OpenApi.Models.References;`
	`7`	`+using Microsoft.OpenApi.Models.Interfaces;`
`7`	`8`
`8`	`9`	`namespace Microsoft.OpenApi.Reader.V31`
`9`	`10`	`{`
`@@ -23,7 +24,7 @@ internal static partial class OpenApiV31Deserializer`
`23`	`24`	`{s => s.StartsWith("x-", StringComparison.OrdinalIgnoreCase), (o, p, n, _) => o.AddExtension(p, LoadExtension(p,n))},`
`24`	`25`	`};`
`25`	`26`
`26`		`- public static OpenApiCallback LoadCallback(ParseNode node, OpenApiDocument hostDocument)`
	`27`	`+ public static IOpenApiCallback LoadCallback(ParseNode node, OpenApiDocument hostDocument)`
`27`	`28`	`{`
`28`	`29`	`var mapNode = node.CheckMapNode("callback");`
`29`	`30`
Original file line number	Diff line number	Diff line change
`@@ -136,9 +136,9 @@ private void AddCallbackToComponents(OpenApiCallback callback, string referenceI`
`136`	`136`	`{`
`137`	`137`	`EnsureComponentsExist();`
`138`	`138`	`EnsureCallbacksExist();`
`139`		`- if (!Components.Callbacks.ContainsKey(referenceId ?? callback.Reference.Id))`
	`139`	`+ if (!Components.Callbacks.ContainsKey(referenceId))`
`140`	`140`	`{`
`141`		`- Components.Callbacks.Add(referenceId ?? callback.Reference.Id, callback);`
	`141`	`+ Components.Callbacks.Add(referenceId, callback);`
`142`	`142`	`}`
`143`	`143`	`}`
`144`	`144`	`private void AddHeaderToComponents(OpenApiHeader header, string referenceId = null)`
`@@ -230,7 +230,7 @@ private void EnsureHeadersExist()`
`230`	`230`
`231`	`231`	`private void EnsureCallbacksExist()`
`232`	`232`	`{`
`233`		`- _target.Components.Callbacks ??= new Dictionary<string, OpenApiCallback>();`
	`233`	`+ _target.Components.Callbacks ??= new Dictionary<string, IOpenApiCallback>();`
`234`	`234`	`}`
`235`	`235`
`236`	`236`	`private void EnsureLinksExist()`