diff --git a/License.txt b/License.txt
index 6a4d2a5..b6a9e37 100644
--- a/License.txt
+++ b/License.txt
@@ -19,3 +19,19 @@ NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPO
 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.
+
+------------------------------------------------------------------------------------------------------------------------------
+
+Certain portions of this code is Copyright (c) 2013, Richard Morris - All rights reserved.
+
+For those portions, the following license applies:
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHA
\ No newline at end of file
diff --git a/README.md b/README.md
index da096ae..8112710 100644
--- a/README.md
+++ b/README.md
@@ -7,8 +7,6 @@ Swashbuckle.OData
 
 Extends Swashbuckle with WebApi OData v4 support!
 
-Implements a custom Swagger Provider that converts an Entity Data Model to a Swagger Document.
-
 ### <a href="http://swashbuckleodata.azurewebsites.net/swagger/" target="_blank">Try it out!</a> ###
 
 ## Getting Started ##
diff --git a/Swashbuckle.OData.Nuget/Swashbuckle.OData.NuGet.nuproj b/Swashbuckle.OData.Nuget/Swashbuckle.OData.NuGet.nuproj
index d486237..5b5ae16 100644
--- a/Swashbuckle.OData.Nuget/Swashbuckle.OData.NuGet.nuproj
+++ b/Swashbuckle.OData.Nuget/Swashbuckle.OData.NuGet.nuproj
@@ -25,12 +25,12 @@
     <Owners>Richard Beauchamp</Owners>
     <Summary>Extends Swashbuckle with WebApi OData v4 support!</Summary>
     <Description>Extends Swashbuckle with WebApi OData v4 support!</Description>
-    <ReleaseNotes>Simplified configuration, upgraded to .NET 4.5, fixed metadata path in Swagger UI, uses correct OData route prefix</ReleaseNotes>
+    <ReleaseNotes>Now supports customization of generated swagger docs via SwaggerConfig, Verifies entity data model against the OData API, Customize output with ApiExplorer-supported attributes</ReleaseNotes>
     <ProjectUrl>https://github.com/rbeauchamp/Swashbuckle.OData</ProjectUrl>
     <LicenseUrl>https://github.com/rbeauchamp/Swashbuckle.OData/blob/master/License.txt</LicenseUrl>
     <Copyright>Copyright 2015</Copyright>
     <Tags>Swashbuckle Swagger SwaggerUi OData Documentation Discovery Help WebApi AspNet AspNetWebApi Docs WebHost IIS</Tags>
-    <Version>2.0.0</Version>
+    <Version>2.1.0</Version>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\Swashbuckle.OData\Swashbuckle.OData.csproj" />
diff --git a/Swashbuckle.OData.Tests/Customer.cs b/Swashbuckle.OData.Sample/ApiControllers/Client.cs
similarity index 53%
rename from Swashbuckle.OData.Tests/Customer.cs
rename to Swashbuckle.OData.Sample/ApiControllers/Client.cs
index 54a36bc..ca9780c 100644
--- a/Swashbuckle.OData.Tests/Customer.cs
+++ b/Swashbuckle.OData.Sample/ApiControllers/Client.cs
@@ -1,13 +1,13 @@
 using System.Collections.Generic;
 
-namespace Swashbuckle.OData.Tests
+namespace SwashbuckleODataSample.Models
 {
-    public class Customer
+    public class Client
     {
         public int Id { get; set; }
 
         public string Name { get; set; }
 
-        public IList<Order> Orders { get; set; }
+        public IList<Project> Projects { get; set; }
     }
 }
\ No newline at end of file
diff --git a/Swashbuckle.OData.Sample/ApiControllers/ClientsController.cs b/Swashbuckle.OData.Sample/ApiControllers/ClientsController.cs
new file mode 100644
index 0000000..8f8183a
--- /dev/null
+++ b/Swashbuckle.OData.Sample/ApiControllers/ClientsController.cs
@@ -0,0 +1,115 @@
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using System.Web.Http;
+using System.Web.Http.Description;
+using SwashbuckleODataSample.Models;
+
+namespace SwashbuckleODataSample.ApiControllers
+{
+    public class ClientsController : ApiController
+    {
+        private readonly SwashbuckleODataContext db = new SwashbuckleODataContext();
+
+        // GET: api/Clients
+        public IQueryable<Client> GetClients()
+        {
+            return db.Clients;
+        }
+
+        // GET: api/Clients/5
+        [ResponseType(typeof (Client))]
+        public async Task<IHttpActionResult> GetClient(int id)
+        {
+            var client = await db.Clients.FindAsync(id);
+            if (client == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(client);
+        }
+
+        // PUT: api/Clients/5
+        [ResponseType(typeof (void))]
+        public async Task<IHttpActionResult> PutClient(int id, Client client)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            if (id != client.Id)
+            {
+                return BadRequest();
+            }
+
+            db.Entry(client).State = EntityState.Modified;
+
+            try
+            {
+                await db.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!ClientExists(id))
+                {
+                    return NotFound();
+                }
+                throw;
+            }
+
+            return StatusCode(HttpStatusCode.NoContent);
+        }
+
+        // POST: api/Clients
+        [ResponseType(typeof (Client))]
+        public async Task<IHttpActionResult> PostClient(Client client)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            db.Clients.Add(client);
+            await db.SaveChangesAsync();
+
+            return CreatedAtRoute("DefaultApi", new
+            {
+                id = client.Id
+            }, client);
+        }
+
+        // DELETE: api/Clients/5
+        [ResponseType(typeof (Client))]
+        public async Task<IHttpActionResult> DeleteClient(int id)
+        {
+            var client = await db.Clients.FindAsync(id);
+            if (client == null)
+            {
+                return NotFound();
+            }
+
+            db.Clients.Remove(client);
+            await db.SaveChangesAsync();
+
+            return Ok(client);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                db.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        private bool ClientExists(int id)
+        {
+            return db.Clients.Count(e => e.Id == id) > 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Sample/ApiControllers/Project.cs b/Swashbuckle.OData.Sample/ApiControllers/Project.cs
new file mode 100644
index 0000000..f41e19e
--- /dev/null
+++ b/Swashbuckle.OData.Sample/ApiControllers/Project.cs
@@ -0,0 +1,21 @@
+using System.ComponentModel.DataAnnotations;
+using System.ComponentModel.DataAnnotations.Schema;
+using System.Web.OData.Builder;
+using Microsoft.OData.Edm;
+
+namespace SwashbuckleODataSample.Models
+{
+    public class Project
+    {
+        [Key]
+        public int ProjectId { get; set; }
+
+        public string ProjectName { get; set; }
+
+        public int ClientId { get; set; }
+
+        [ForeignKey("ClientId")]
+        [ActionOnDelete(EdmOnDeleteAction.Cascade)]
+        public Client Client { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Sample/ApiControllers/ProjectsController.cs b/Swashbuckle.OData.Sample/ApiControllers/ProjectsController.cs
new file mode 100644
index 0000000..7cc16c7
--- /dev/null
+++ b/Swashbuckle.OData.Sample/ApiControllers/ProjectsController.cs
@@ -0,0 +1,115 @@
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+using System.Linq;
+using System.Net;
+using System.Threading.Tasks;
+using System.Web.Http;
+using System.Web.Http.Description;
+using SwashbuckleODataSample.Models;
+
+namespace SwashbuckleODataSample.ApiControllers
+{
+    public class ProjectsController : ApiController
+    {
+        private readonly SwashbuckleODataContext db = new SwashbuckleODataContext();
+
+        [Route("Projects/v1")]
+        public IQueryable<Project> GetProjects()
+        {
+            return db.Projects;
+        }
+
+        [Route("Projects/v1/{id}")]
+        [ResponseType(typeof (Project))]
+        public async Task<IHttpActionResult> GetProject(int id)
+        {
+            var project = await db.Projects.FindAsync(id);
+            if (project == null)
+            {
+                return NotFound();
+            }
+
+            return Ok(project);
+        }
+
+        [Route("Projects/v1/{id}")]
+        [ResponseType(typeof (void))]
+        public async Task<IHttpActionResult> PutProject(int id, Project project)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            if (id != project.ProjectId)
+            {
+                return BadRequest();
+            }
+
+            db.Entry(project).State = EntityState.Modified;
+
+            try
+            {
+                await db.SaveChangesAsync();
+            }
+            catch (DbUpdateConcurrencyException)
+            {
+                if (!ProjectExists(id))
+                {
+                    return NotFound();
+                }
+                throw;
+            }
+
+            return StatusCode(HttpStatusCode.NoContent);
+        }
+
+        [Route("Projects/v1")]
+        [ResponseType(typeof (Project))]
+        public async Task<IHttpActionResult> PostProject(Project project)
+        {
+            if (!ModelState.IsValid)
+            {
+                return BadRequest(ModelState);
+            }
+
+            db.Projects.Add(project);
+            await db.SaveChangesAsync();
+
+            return CreatedAtRoute("DefaultApi", new
+            {
+                id = project.ProjectId
+            }, project);
+        }
+
+        [Route("Projects/v1/{id}")]
+        [ResponseType(typeof (Project))]
+        public async Task<IHttpActionResult> DeleteProject(int id)
+        {
+            var project = await db.Projects.FindAsync(id);
+            if (project == null)
+            {
+                return NotFound();
+            }
+
+            db.Projects.Remove(project);
+            await db.SaveChangesAsync();
+
+            return Ok(project);
+        }
+
+        protected override void Dispose(bool disposing)
+        {
+            if (disposing)
+            {
+                db.Dispose();
+            }
+            base.Dispose(disposing);
+        }
+
+        private bool ProjectExists(int id)
+        {
+            return db.Projects.Count(e => e.ProjectId == id) > 0;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Sample/App_Start/FormatterConfig.cs b/Swashbuckle.OData.Sample/App_Start/FormatterConfig.cs
new file mode 100644
index 0000000..8236a01
--- /dev/null
+++ b/Swashbuckle.OData.Sample/App_Start/FormatterConfig.cs
@@ -0,0 +1,31 @@
+using System.Web.Http;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Converters;
+using Newtonsoft.Json.Serialization;
+
+namespace SwashbuckleODataSample
+{
+    /// <summary>
+    /// </summary>
+    public static class FormatterConfig
+    {
+        /// <summary>
+        /// Registers the specified configuration.
+        /// </summary>
+        /// <param name="config">The configuration.</param>
+        public static void Register(HttpConfiguration config)
+        {
+            var formatters = config.Formatters;
+
+            formatters.JsonFormatter.SerializerSettings = new JsonSerializerSettings
+            {
+                NullValueHandling = NullValueHandling.Ignore,
+                DateFormatHandling = DateFormatHandling.IsoDateFormat,
+                DateTimeZoneHandling = DateTimeZoneHandling.Utc,
+                MetadataPropertyHandling = MetadataPropertyHandling.Ignore
+            };
+
+            formatters.JsonFormatter.SerializerSettings.Converters.Add(new StringEnumConverter());
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Sample/App_Start/SwaggerConfig.cs b/Swashbuckle.OData.Sample/App_Start/SwaggerConfig.cs
index 2a33550..4674416 100644
--- a/Swashbuckle.OData.Sample/App_Start/SwaggerConfig.cs
+++ b/Swashbuckle.OData.Sample/App_Start/SwaggerConfig.cs
@@ -1,4 +1,5 @@
 using System.Web.Http;
+using System.Web.Http.Description;
 using Swashbuckle.Application;
 using Swashbuckle.OData;
 using SwashbuckleODataSample;
diff --git a/Swashbuckle.OData.Sample/App_Start/WebApiConfig.cs b/Swashbuckle.OData.Sample/App_Start/WebApiConfig.cs
index de850dc..d903407 100644
--- a/Swashbuckle.OData.Sample/App_Start/WebApiConfig.cs
+++ b/Swashbuckle.OData.Sample/App_Start/WebApiConfig.cs
@@ -16,6 +16,12 @@ public static void Register(HttpConfiguration config)
             // Web API routes
             config.MapHttpAttributeRoutes();
 
+            config.Routes.MapHttpRoute(
+                name: "DefaultApi",
+                routeTemplate: "api/{controller}/{id}",
+                defaults: new { id = RouteParameter.Optional }
+            );
+
             var builder = new ODataConventionModelBuilder();
             builder.EntitySet<Customer>("Customers");
             builder.EntitySet<Order>("Orders");
diff --git a/Swashbuckle.OData.Sample/Global.asax.cs b/Swashbuckle.OData.Sample/Global.asax.cs
index ee5ee60..f14d434 100644
--- a/Swashbuckle.OData.Sample/Global.asax.cs
+++ b/Swashbuckle.OData.Sample/Global.asax.cs
@@ -8,6 +8,7 @@ public class WebApiApplication : HttpApplication
         protected void Application_Start()
         {
             GlobalConfiguration.Configure(WebApiConfig.Register);
+            GlobalConfiguration.Configure(FormatterConfig.Register);
         }
     }
 }
\ No newline at end of file
diff --git a/Swashbuckle.OData.Sample/Models/SwashbuckleODataContext.cs b/Swashbuckle.OData.Sample/Models/SwashbuckleODataContext.cs
deleted file mode 100644
index 357138e..0000000
--- a/Swashbuckle.OData.Sample/Models/SwashbuckleODataContext.cs
+++ /dev/null
@@ -1,22 +0,0 @@
-using System.Data.Entity;
-
-namespace SwashbuckleODataSample.Models
-{
-    public class SwashbuckleODataContext : DbContext
-    {
-        // You can add custom code to this file. Changes will not be overwritten.
-        // 
-        // If you want Entity Framework to drop and regenerate your database
-        // automatically whenever you change your model schema, please use data migrations.
-        // For more information refer to the documentation:
-        // http://msdn.microsoft.com/en-us/data/jj591621.aspx
-
-        public SwashbuckleODataContext() : base("name=SwashbuckleODataContext")
-        {
-        }
-
-        public DbSet<Customer> Customers { get; set; }
-
-        public DbSet<Order> Orders { get; set; }
-    }
-}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Sample/Models/Customer.cs b/Swashbuckle.OData.Sample/ODataControllers/Customer.cs
similarity index 100%
rename from Swashbuckle.OData.Sample/Models/Customer.cs
rename to Swashbuckle.OData.Sample/ODataControllers/Customer.cs
diff --git a/Swashbuckle.OData.Sample/Controllers/CustomersController.cs b/Swashbuckle.OData.Sample/ODataControllers/CustomersController.cs
similarity index 94%
rename from Swashbuckle.OData.Sample/Controllers/CustomersController.cs
rename to Swashbuckle.OData.Sample/ODataControllers/CustomersController.cs
index 9cb9c95..d7f55db 100644
--- a/Swashbuckle.OData.Sample/Controllers/CustomersController.cs
+++ b/Swashbuckle.OData.Sample/ODataControllers/CustomersController.cs
@@ -3,7 +3,9 @@
 using System.Net;
 using System.Threading.Tasks;
 using System.Web.Http;
+using System.Web.Http.Description;
 using System.Web.OData;
+using System.Web.OData.Results;
 using SwashbuckleODataSample.Models;
 
 namespace SwashbuckleODataSample.Controllers
@@ -27,6 +29,7 @@ public SingleResult<Customer> GetCustomer([FromODataUri] int key)
         }
 
         // PUT: odata/Customers(5)
+        [ResponseType(typeof(void))]
         public async Task<IHttpActionResult> Put([FromODataUri] int key, Delta<Customer> patch)
         {
             Validate(patch.GetEntity());
@@ -61,6 +64,7 @@ public async Task<IHttpActionResult> Put([FromODataUri] int key, Delta<Customer>
         }
 
         // POST: odata/Customers
+        [ResponseType(typeof(Customer))]
         public async Task<IHttpActionResult> Post(Customer customer)
         {
             if (!ModelState.IsValid)
@@ -75,6 +79,7 @@ public async Task<IHttpActionResult> Post(Customer customer)
         }
 
         // PATCH: odata/Customers(5)
+        [ResponseType(typeof(void))]
         [AcceptVerbs("PATCH", "MERGE")]
         public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Customer> patch)
         {
@@ -110,6 +115,7 @@ public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Custome
         }
 
         // DELETE: odata/Customers(5)
+        [ResponseType(typeof(void))]
         public async Task<IHttpActionResult> Delete([FromODataUri] int key)
         {
             var customer = await _db.Customers.FindAsync(key);
diff --git a/Swashbuckle.OData.Sample/Models/Order.cs b/Swashbuckle.OData.Sample/ODataControllers/Order.cs
similarity index 100%
rename from Swashbuckle.OData.Sample/Models/Order.cs
rename to Swashbuckle.OData.Sample/ODataControllers/Order.cs
diff --git a/Swashbuckle.OData.Sample/Controllers/OrdersController.cs b/Swashbuckle.OData.Sample/ODataControllers/OrdersController.cs
similarity index 78%
rename from Swashbuckle.OData.Sample/Controllers/OrdersController.cs
rename to Swashbuckle.OData.Sample/ODataControllers/OrdersController.cs
index 33fe67b..ed27cb2 100644
--- a/Swashbuckle.OData.Sample/Controllers/OrdersController.cs
+++ b/Swashbuckle.OData.Sample/ODataControllers/OrdersController.cs
@@ -3,6 +3,7 @@
 using System.Net;
 using System.Threading.Tasks;
 using System.Web.Http;
+using System.Web.Http.Description;
 using System.Web.OData;
 using SwashbuckleODataSample.Models;
 
@@ -26,41 +27,8 @@ public SingleResult<Order> GetOrder([FromODataUri] int key)
             return SingleResult.Create(_db.Orders.Where(order => order.OrderId == key));
         }
 
-        // PUT: odata/Orders(5)
-        public async Task<IHttpActionResult> Put([FromODataUri] int key, Delta<Order> patch)
-        {
-            Validate(patch.GetEntity());
-
-            if (!ModelState.IsValid)
-            {
-                return BadRequest(ModelState);
-            }
-
-            var order = await _db.Orders.FindAsync(key);
-            if (order == null)
-            {
-                return NotFound();
-            }
-
-            patch.Put(order);
-
-            try
-            {
-                await _db.SaveChangesAsync();
-            }
-            catch (DbUpdateConcurrencyException)
-            {
-                if (!OrderExists(key))
-                {
-                    return NotFound();
-                }
-                throw;
-            }
-
-            return Updated(order);
-        }
-
         // POST: odata/Orders
+        [ResponseType(typeof(Order))]
         public async Task<IHttpActionResult> Post(Order order)
         {
             if (!ModelState.IsValid)
@@ -75,6 +43,7 @@ public async Task<IHttpActionResult> Post(Order order)
         }
 
         // PATCH: odata/Orders(5)
+        [ResponseType(typeof(void))]
         [AcceptVerbs("PATCH", "MERGE")]
         public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Order> patch)
         {
@@ -110,6 +79,7 @@ public async Task<IHttpActionResult> Patch([FromODataUri] int key, Delta<Order>
         }
 
         // DELETE: odata/Orders(5)
+        [ResponseType(typeof(void))]
         public async Task<IHttpActionResult> Delete([FromODataUri] int key)
         {
             var order = await _db.Orders.FindAsync(key);
diff --git a/Swashbuckle.OData.Sample/ODataControllers/SwashbuckleODataContext.cs b/Swashbuckle.OData.Sample/ODataControllers/SwashbuckleODataContext.cs
new file mode 100644
index 0000000..1c97840
--- /dev/null
+++ b/Swashbuckle.OData.Sample/ODataControllers/SwashbuckleODataContext.cs
@@ -0,0 +1,47 @@
+using System.Data.Entity;
+
+namespace SwashbuckleODataSample.Models
+{
+    public class SwashbuckleODataContext : DbContext
+    {
+        static SwashbuckleODataContext()
+        {
+            Database.SetInitializer(new SwashbuckleODataInitializer());
+        }
+
+
+        public SwashbuckleODataContext() : base("name=SwashbuckleODataContext")
+        {
+        }
+
+        public DbSet<Customer> Customers { get; set; }
+
+        public DbSet<Order> Orders { get; set; }
+
+        public DbSet<Client> Clients { get; set; }
+
+        public DbSet<Project> Projects { get; set; }
+    }
+
+    public class SwashbuckleODataInitializer : DropCreateDatabaseAlways<SwashbuckleODataContext>
+    {
+        protected override void Seed(SwashbuckleODataContext context)
+        {
+            var clientOne = new Client { Name = "ClientOne" };
+            context.Clients.Add(clientOne);
+            context.Clients.Add(new Client { Name = "ClientTwo" });
+
+            context.Projects.Add(new Project { ProjectName = "ProjectOne", Client = clientOne});
+            context.Projects.Add(new Project { ProjectName = "ProjectTwo", Client = clientOne});
+
+            var customerOne = new Customer { Name = "CustomerOne" };
+            context.Customers.Add(customerOne);
+            context.Customers.Add(new Customer { Name = "CustomerTwo" });
+
+            context.Orders.Add(new Order { OrderName = "OrderOne", Customer = customerOne });
+            context.Orders.Add(new Order { OrderName = "OrderTwo", Customer = customerOne });
+
+            base.Seed(context);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Sample/Swashbuckle.OData.Sample.csproj b/Swashbuckle.OData.Sample/Swashbuckle.OData.Sample.csproj
index 87c1148..2994e4d 100644
--- a/Swashbuckle.OData.Sample/Swashbuckle.OData.Sample.csproj
+++ b/Swashbuckle.OData.Sample/Swashbuckle.OData.Sample.csproj
@@ -119,16 +119,21 @@
     <Folder Include="App_Data\" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="ApiControllers\Client.cs" />
+    <Compile Include="ApiControllers\ClientsController.cs" />
+    <Compile Include="ApiControllers\Project.cs" />
+    <Compile Include="ApiControllers\ProjectsController.cs" />
+    <Compile Include="App_Start\FormatterConfig.cs" />
     <Compile Include="App_Start\SwaggerConfig.cs" />
     <Compile Include="App_Start\WebApiConfig.cs" />
-    <Compile Include="Controllers\CustomersController.cs" />
-    <Compile Include="Controllers\OrdersController.cs" />
+    <Compile Include="ODataControllers\Customer.cs" />
+    <Compile Include="ODataControllers\CustomersController.cs" />
+    <Compile Include="ODataControllers\Order.cs" />
+    <Compile Include="ODataControllers\OrdersController.cs" />
     <Compile Include="Global.asax.cs">
       <DependentUpon>Global.asax</DependentUpon>
     </Compile>
-    <Compile Include="Models\Customer.cs" />
-    <Compile Include="Models\Order.cs" />
-    <Compile Include="Models\SwashbuckleODataContext.cs" />
+    <Compile Include="ODataControllers\SwashbuckleODataContext.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
   </ItemGroup>
   <ItemGroup>
diff --git a/Swashbuckle.OData.Tests/ApplyDocumentVendorExtensions.cs b/Swashbuckle.OData.Tests/ApplyDocumentVendorExtensions.cs
new file mode 100644
index 0000000..af2cd84
--- /dev/null
+++ b/Swashbuckle.OData.Tests/ApplyDocumentVendorExtensions.cs
@@ -0,0 +1,13 @@
+using System.Web.Http.Description;
+using Swashbuckle.Swagger;
+
+namespace Swashbuckle.OData.Tests
+{
+    public class ApplyDocumentVendorExtensions : IDocumentFilter
+    {
+        public void Apply(SwaggerDocument swaggerDoc, SchemaRegistry schemaRegistry, IApiExplorer apiExplorer)
+        {
+            swaggerDoc.host = "foo";
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Tests/ContentType.cs b/Swashbuckle.OData.Tests/ContentType.cs
new file mode 100644
index 0000000..5df220f
--- /dev/null
+++ b/Swashbuckle.OData.Tests/ContentType.cs
@@ -0,0 +1,328 @@
+using System;
+
+namespace Swashbuckle.OData.Tests
+{
+    public static class ContentType
+    {
+        /// <summary>
+        /// Used to denote the encoding necessary for files containing JavaScript source code. The alternative MIME type for this file type is text/javascript.
+        /// </summary>
+        public const string ApplicationXJavascript = "application/x-javascript";
+
+        ///<summary>24bit Linear PCM audio at 8-48kHz, 1-N channels; Defined in RFC 3190</summary>
+        public const string AudioL24 = "audio/L24";
+
+        ///<summary>Adobe Flash files for example with the extension .swf</summary>
+        public const string ApplicationXShockwaveFlash = "application/x-shockwave-flash";
+
+        ///<summary>Arbitrary binary data.[5] Generally speaking this type identifies files that are not associated with a specific application. Contrary to past assumptions by software packages such as Apache this is not a type that should be applied to unknown files. In such a case, a server or application should not indicate a content type, as it may be incorrect, but rather, should omit the type in order to allow the recipient to guess the type.[6]</summary>
+        public const string ApplicationOctetStream = "application/octet-stream";
+
+        ///<summary>Atom feeds</summary>
+        public const string ApplicationAtomXml = "application/atom+xml";
+
+        ///<summary>Cascading Style Sheets; Defined in RFC 2318</summary>
+        public const string TextCss = "text/css";
+
+        ///<summary>commands; subtype resident in Gecko browsers like Firefox 3.5</summary>
+        public const string TextCmd = "text/cmd";
+
+        ///<summary>Comma-separated values; Defined in RFC 4180</summary>
+        public const string TextCsv = "text/csv";
+
+        ///<summary>deb (file format), a software package format used by the Debian project</summary>
+        public const string ApplicationXDeb = "application/x-deb";
+
+        ///<summary>Defined in RFC 1847</summary>
+        public const string MultipartEncrypted = "multipart/encrypted";
+
+        ///<summary>Defined in RFC 1847</summary>
+        public const string MultipartSigned = "multipart/signed";
+
+        ///<summary>Defined in RFC 2616</summary>
+        public const string MessageHttp = "message/http";
+
+        ///<summary>Defined in RFC 4735</summary>
+        public const string ModelExample = "model/example";
+
+        ///<summary>device-independent document in DVI format</summary>
+        public const string ApplicationXDvi = "application/x-dvi";
+
+        ///<summary>DTD files; Defined by RFC 3023</summary>
+        public const string ApplicationXmlDtd = "application/xml-dtd";
+
+        ///<summary>ECMAScript/JavaScript; Defined in RFC 4329 (equivalent to application/ecmascript but with looser processing rules) It is not accepted in IE 8 or earlier - text/javascript is accepted but it is defined as obsolete in RFC 4329. The "type" attribute of the <script> tag in HTML5 is optional and in practice omitting the media type of JavaScript programs is the most interoperable solution since all browsers have always assumed the correct default even before HTML5.</summary>
+        public const string ApplicationJavascript = "application/javascript";
+
+        ///<summary>ECMAScript/JavaScript; Defined in RFC 4329 (equivalent to application/javascript but with stricter processing rules)</summary>
+        public const string ApplicationEcmascript = "application/ecmascript";
+
+        ///<summary>EDI EDIFACT data; Defined in RFC 1767</summary>
+        public const string ApplicationEdifact = "application/EDIFACT";
+
+        ///<summary>EDI X12 data; Defined in RFC 1767</summary>
+        public const string ApplicationEdiX12 = "application/EDI-X12";
+
+        ///<summary>Email; Defined in RFC 2045 and RFC 2046</summary>
+        public const string MessagePartial = "message/partial";
+
+        ///<summary>Email; EML files, MIME files, MHT files, MHTML files; Defined in RFC 2045 and RFC 2046</summary>
+        public const string MessageRfc822 = "message/rfc822";
+
+        ///<summary>Extensible Markup Language; Defined in RFC 3023</summary>
+        public const string TextXml = "text/xml";
+
+        ///<summary>Flash video (FLV files)</summary>
+        public const string VideoXFlv = "video/x-flv";
+
+        ///<summary>GIF image; Defined in RFC 2045 and RFC 2046</summary>
+        public const string ImageGif = "image/gif";
+
+        ///<summary>GoogleWebToolkit data</summary>
+        public const string TextXGwtRpc = "text/x-gwt-rpc";
+
+        ///<summary>Gzip</summary>
+        public const string ApplicationXGzip = "application/x-gzip";
+
+        ///<summary>HTML; Defined in RFC 2854</summary>
+        public const string TextHtml = "text/html";
+
+        ///<summary>ICO image; Registered[9]</summary>
+        public const string ImageVndMicrosoftIcon = "image/vnd.microsoft.icon";
+
+        ///<summary>IGS files, IGES files; Defined in RFC 2077</summary>
+        public const string ModelIges = "model/iges";
+
+        ///<summary>IMDN Instant Message Disposition Notification; Defined in RFC 5438</summary>
+        public const string MessageImdnXml = "message/imdn+xml";
+
+        ///<summary>JavaScript Object Notation JSON; Defined in RFC 4627</summary>
+        public const string ApplicationJson = "application/json";
+
+        ///<summary>JavaScript - Defined in and obsoleted by RFC 4329 in order to discourage its usage in favor of application/javascript. However,text/javascript is allowed in HTML 4 and 5 and, unlike application/javascript, has cross-browser support. The "type" attribute of the <script> tag in HTML5 is optional and there is no need to use it at all since all browsers have always assumed the correct default (even in HTML 4 where it was required by the specification).</summary>
+        [Obsolete]
+        public const string TextJavascript = "text/javascript";
+
+        ///<summary>JPEG JFIF image; Associated with Internet Explorer; Listed in ms775147(v=vs.85) - Progressive JPEG, initiated before global browser support for progressive JPEGs (Microsoft and Firefox).</summary>
+        public const string ImagePjpeg = "image/pjpeg";
+
+        ///<summary>JPEG JFIF image; Defined in RFC 2045 and RFC 2046</summary>
+        public const string ImageJpeg = "image/jpeg";
+
+        ///<summary>jQuery template data</summary>
+        public const string TextXJqueryTmpl = "text/x-jquery-tmpl";
+
+        ///<summary>KML files (e.g. for Google Earth)</summary>
+        public const string ApplicationVndGoogleEarthKmlXml = "application/vnd.google-earth.kml+xml";
+
+        ///<summary>LaTeX files</summary>
+        public const string ApplicationXLatex = "application/x-latex";
+
+        ///<summary>Matroska open media format</summary>
+        public const string VideoXMatroska = "video/x-matroska";
+
+        ///<summary>Microsoft Excel 2007 files</summary>
+        public const string ApplicationVndOpenxmlformatsOfficedocumentSpreadsheetmlSheet = "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+
+        ///<summary>Microsoft Excel files</summary>
+        public const string ApplicationVndMsExcel = "application/vnd.ms-excel";
+
+        ///<summary>Microsoft Powerpoint 2007 files</summary>
+        public const string ApplicationVndOpenxmlformatsOfficedocumentPresentationmlPresentation = "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+
+        ///<summary>Microsoft Powerpoint files</summary>
+        public const string ApplicationVndMsPowerpoint = "application/vnd.ms-powerpoint";
+
+        ///<summary>Microsoft Word 2007 files</summary>
+        public const string ApplicationVndOpenxmlformatsOfficedocumentWordprocessingmlDocument = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+
+        ///<summary>Microsoft Word files[15]</summary>
+        public const string ApplicationMsword = "application/msword";
+
+        ///<summary>MIME Email; Defined in RFC 2045 and RFC 2046</summary>
+        public const string MultipartAlternative = "multipart/alternative";
+
+        ///<summary>MIME Email; Defined in RFC 2045 and RFC 2046</summary>
+        public const string MultipartMixed = "multipart/mixed";
+
+        ///<summary>MIME Email; Defined in RFC 2387 and used by MHTML (HTML mail)</summary>
+        public const string MultipartRelated = "multipart/related";
+
+        ///<summary>MIME Webform; Defined in RFC 2388</summary>
+        public const string MultipartFormData = "multipart/form-data";
+
+        ///<summary>Mozilla XUL files</summary>
+        public const string ApplicationVndMozillaXulXml = "application/vnd.mozilla.xul+xml";
+
+        ///<summary>MP3 or other MPEG audio; Defined in RFC 3003</summary>
+        public const string AudioMpeg = "audio/mpeg";
+
+        ///<summary>MP4 audio</summary>
+        public const string AudioMp4 = "audio/mp4";
+
+        ///<summary>MP4 video; Defined in RFC 4337</summary>
+        public const string VideoMp4 = "video/mp4";
+
+        ///<summary>MPEG-1 video with multiplexed audio; Defined in RFC 2045 and RFC 2046</summary>
+        public const string VideoMpeg = "video/mpeg";
+
+        ///<summary>MSH files, MESH files; Defined in RFC 2077, SILO files</summary>
+        public const string ModelMesh = "model/mesh";
+
+        ///<summary>mulaw audio at 8 kHz, 1 channel; Defined in RFC 2046</summary>
+        public const string AudioBasic = "audio/basic";
+
+        ///<summary>Ogg Theora or other video (with audio); Defined in RFC 5334</summary>
+        public const string VideoOgg = "video/ogg";
+
+        ///<summary>Ogg Vorbis, Speex, Flac and other audio; Defined in RFC 5334</summary>
+        public const string AudioOgg = "audio/ogg";
+
+        ///<summary>Ogg, a multimedia bitstream container format; Defined in RFC 5334</summary>
+        public const string ApplicationOgg = "application/ogg";
+
+        ///<summary>OP</summary>
+        public const string ApplicationXopXml = "application/xop+xml";
+
+        ///<summary>OpenDocument Graphics; Registered[14]</summary>
+        public const string ApplicationVndOasisOpendocumentGraphics = "application/vnd.oasis.opendocument.graphics";
+
+        ///<summary>OpenDocument Presentation; Registered[13]</summary>
+        public const string ApplicationVndOasisOpendocumentPresentation = "application/vnd.oasis.opendocument.presentation";
+
+        ///<summary>OpenDocument Spreadsheet; Registered[12]</summary>
+        public const string ApplicationVndOasisOpendocumentSpreadsheet = "application/vnd.oasis.opendocument.spreadsheet";
+
+        ///<summary>OpenDocument Text; Registered[11]</summary>
+        public const string ApplicationVndOasisOpendocumentText = "application/vnd.oasis.opendocument.text";
+
+        ///<summary>p12 files</summary>
+        public const string ApplicationXPkcs12 = "application/x-pkcs12";
+
+        ///<summary>p7b and spc files</summary>
+        public const string ApplicationXPkcs7Certificates = "application/x-pkcs7-certificates";
+
+        ///<summary>p7c files</summary>
+        public const string ApplicationXPkcs7Mime = "application/x-pkcs7-mime";
+
+        /// <summary>
+        /// p7r files
+        /// </summary>
+        public const string ApplicationXPkcs7Certreqresp = "application/x-pkcs7-certreqresp";
+
+        /// <summary>
+        /// p7s files
+        /// </summary>
+        public const string ApplicationXPkcs7Signature = "application/x-pkcs7-signature";
+
+        /// <summary>
+        /// Portable Document Format, PDF has been in use for document exchange on the Internet since 1993; Defined in RFC 3778
+        /// </summary>
+        public const string ApplicationPdf = "application/pdf";
+
+        /// <summary>
+        /// Portable Network Graphics; Registered,[8] Defined in RFC 2083
+        /// </summary>
+        public const string ImagePng = "image/png";
+
+        /// <summary>
+        /// PostScript; Defined in RFC 2046
+        /// </summary>
+        public const string ApplicationPostscript = "application/postscript";
+
+        /// <summary>
+        /// QuickTime video; Registered[10]
+        /// </summary>
+        public const string VideoQuicktime = "video/quicktime";
+
+        /// <summary>
+        /// RAR archive files
+        /// </summary>
+        public const string ApplicationXRarCompressed = "application/x-rar-compressed";
+
+        /// <summary>
+        /// RealAudio; Documented in RealPlayer Customer Support Answer 2559
+        /// </summary>
+        public const string AudioVndRnRealaudio = "audio/vnd.rn-realaudio";
+
+        /// <summary>
+        /// Resource Description Framework; Defined by RFC 3870
+        /// </summary>
+        public const string ApplicationRdfXml = "application/rdf+xml";
+
+        /// <summary>
+        /// RSS feeds
+        /// </summary>
+        public const string ApplicationRssXml = "application/rss+xml";
+
+        /// <summary>
+        /// SOAP; Defined by RFC 3902
+        /// </summary>
+        public const string ApplicationSoapXml = "application/soap+xml";
+
+        /// <summary>
+        /// StuffIt archive files
+        /// </summary>
+        public const string ApplicationXStuffit = "application/x-stuffit";
+
+        ///<summary>SVG vector image; Defined in SVG Tiny 1.2 Specification Appendix M</summary>
+        public const string ImageSvgXml = "image/svg+xml";
+
+        ///<summary>Tag Image File Format (only for Baseline TIFF); Defined in RFC 3302</summary>
+        public const string ImageTiff = "image/tiff";
+
+        ///<summary>Tarball files</summary>
+        public const string ApplicationXTar = "application/x-tar";
+
+        ///<summary>Textual data; Defined in RFC 2046 and RFC 3676</summary>
+        public const string TextPlain = "text/plain";
+
+        ///<summary>TrueType Font No registered MIME type, but this is the most commonly used</summary>
+        public const string ApplicationXFontTtf = "application/x-font-ttf";
+
+        ///<summary>vCard (contact information); Defined in RFC 6350</summary>
+        public const string TextVcard = "text/vcard";
+
+        ///<summary>Vorbis encoded audio; Defined in RFC 5215</summary>
+        public const string AudioVorbis = "audio/vorbis";
+
+        ///<summary>WAV audio; Defined in RFC 2361</summary>
+        public const string AudioVndWave = "audio/vnd.wave";
+
+        ///<summary>Web Open Font Format; (candidate recommendation; use application/x-font-woff until standard is official)</summary>
+        public const string ApplicationFontWoff = "application/font-woff";
+
+        ///<summary>WebM Matroska-based open media format</summary>
+        public const string VideoWebm = "video/webm";
+
+        ///<summary>WebM open media format</summary>
+        public const string AudioWebm = "audio/webm";
+
+        ///<summary>Windows Media Audio Redirector; Documented in Microsoft help page</summary>
+        public const string AudioXMsWax = "audio/x-ms-wax";
+
+        ///<summary>Windows Media Audio; Documented in Microsoft KB 288102</summary>
+        public const string AudioXMsWma = "audio/x-ms-wma";
+
+        ///<summary>Windows Media Video; Documented in Microsoft KB 288102</summary>
+        public const string VideoXMsWmv = "video/x-ms-wmv";
+
+        ///<summary>WRL files, VRML files; Defined in RFC 2077</summary>
+        public const string ModelVrml = "model/vrml";
+
+        ///<summary>X3D ISO standard for representing 3D computer graphics, X3D XML files</summary>
+        public const string ModelX3DXml = "model/x3d+xml";
+
+        ///<summary>X3D ISO standard for representing 3D computer graphics, X3DB binary files</summary>
+        public const string ModelX3DBinary = "model/x3d+binary";
+
+        ///<summary>X3D ISO standard for representing 3D computer graphics, X3DV VRML files</summary>
+        public const string ModelX3DVrml = "model/x3d+vrml";
+
+        ///<summary>XHTML; Defined by RFC 3236</summary>
+        public const string ApplicationXhtmlXml = "application/xhtml+xml";
+
+        ///<summary>ZIP archive files; Registered[7]</summary>
+        public const string ApplicationZip = "application/zip";
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Tests/Fixtures/GetTests.cs b/Swashbuckle.OData.Tests/Fixtures/GetTests.cs
new file mode 100644
index 0000000..0cbd72d
--- /dev/null
+++ b/Swashbuckle.OData.Tests/Fixtures/GetTests.cs
@@ -0,0 +1,77 @@
+using System.Linq;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.Owin.Hosting;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
+using NUnit.Framework;
+using Swashbuckle.OData.Tests.WebHost;
+using Swashbuckle.Swagger;
+
+namespace Swashbuckle.OData.Tests
+{
+    [TestFixture]
+    public class GetTests
+    {
+        [Test]
+        public async Task It_includes_the_filter_parameter()
+        {
+            using (WebApp.Start(TestWebApiStartup.BaseAddress, appBuilder => new TestWebApiStartup().Configuration(appBuilder)))
+            {
+                // Arrange
+                var httpClient = HttpClientUtils.GetHttpClient();
+
+                // Act
+                var swaggerDocument = await httpClient.GetJsonAsync<SwaggerDocument>("swagger/docs/v1");
+
+                // Assert
+                PathItem pathItem;
+                swaggerDocument.paths.TryGetValue("/Customers", out pathItem);
+                pathItem.Should().NotBeNull();
+                var filterParameter = pathItem.get.parameters.SingleOrDefault(parameter => parameter.name == "$filter");
+                filterParameter.Should().NotBeNull();
+                filterParameter.description.Should().NotBeNullOrWhiteSpace();
+                filterParameter.type.ShouldBeEquivalentTo("string");
+                filterParameter.@in.ShouldBeEquivalentTo("query");
+            }
+        }
+
+        [Test]
+        public async Task It_has_all_optional_odata_query_parameters()
+        {
+            using (WebApp.Start(TestWebApiStartup.BaseAddress, appBuilder => new TestWebApiStartup().Configuration(appBuilder)))
+            {
+                // Arrange
+                var httpClient = HttpClientUtils.GetHttpClient();
+
+                // Act
+                var swaggerDocument = await httpClient.GetJsonAsync<SwaggerDocument>("swagger/docs/v1");
+
+                // Assert
+                PathItem pathItem;
+                swaggerDocument.paths.TryGetValue("/Customers", out pathItem);
+                pathItem.get.parameters.Where(parameter => parameter.name.StartsWith("$")).Should().OnlyContain(parameter => parameter.required == false);
+            }
+        }
+
+        [Test]
+        public async Task It_has_a_parameter_with_a_name_equal_to_the_path_name()
+        {
+            using (WebApp.Start(TestWebApiStartup.BaseAddress, appBuilder => new TestWebApiStartup().Configuration(appBuilder)))
+            {
+                // Arrange
+                var httpClient = HttpClientUtils.GetHttpClient();
+
+                // Act
+                var swaggerDocument = await httpClient.GetJsonAsync<SwaggerDocument>("swagger/docs/v1");
+
+                // Assert
+                PathItem pathItem;
+                swaggerDocument.paths.TryGetValue("/Customers({Id})", out pathItem);
+                pathItem.Should().NotBeNull();
+                pathItem.get.Should().NotBeNull();
+                pathItem.get.parameters.Should().Contain(parameter => parameter.name == "Id");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Tests/HttpConfigurationRoutesTests.cs b/Swashbuckle.OData.Tests/Fixtures/HttpConfigurationRoutesTests.cs
similarity index 90%
rename from Swashbuckle.OData.Tests/HttpConfigurationRoutesTests.cs
rename to Swashbuckle.OData.Tests/Fixtures/HttpConfigurationRoutesTests.cs
index 0b3872b..289c9b1 100644
--- a/Swashbuckle.OData.Tests/HttpConfigurationRoutesTests.cs
+++ b/Swashbuckle.OData.Tests/Fixtures/HttpConfigurationRoutesTests.cs
@@ -26,7 +26,7 @@ public async Task It_gets_the_route_prefix_from_config_MapODataServiceRoute()
                 var httpClient = HttpClientUtils.GetHttpClient();
 
                 // Act
-                var swaggerDocument = await httpClient.GetAsync<SwaggerDocument>("swagger/docs/v1");
+                var swaggerDocument = await httpClient.GetJsonAsync<SwaggerDocument>("swagger/docs/v1");
 
                 // Assert
                 swaggerDocument.basePath.ShouldBeEquivalentTo("/" + WebApiConfig.ODataRoutePrefix);
diff --git a/Swashbuckle.OData.Tests/Fixtures/ODataSwaggerProviderTests.cs b/Swashbuckle.OData.Tests/Fixtures/ODataSwaggerProviderTests.cs
new file mode 100644
index 0000000..1c03b1d
--- /dev/null
+++ b/Swashbuckle.OData.Tests/Fixtures/ODataSwaggerProviderTests.cs
@@ -0,0 +1,33 @@
+using System;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.Owin.Hosting;
+using Newtonsoft.Json.Linq;
+using NUnit.Framework;
+using Swashbuckle.Application;
+using Swashbuckle.OData.Tests.WebHost;
+using Swashbuckle.Swagger;
+
+namespace Swashbuckle.OData.Tests
+{
+    [TestFixture]
+    public class ODataSwaggerProviderTests
+    {
+        [Test]
+        public async Task It_applies_document_filters()
+        {
+            // Arrange
+            Action<SwaggerDocsConfig> config = c => c.DocumentFilter<ApplyDocumentVendorExtensions>();
+            var httpClient = HttpClientUtils.GetHttpClient();
+
+            using (WebApp.Start(TestWebApiStartup.BaseAddress, appBuilder => new TestWebApiStartup().Configuration(appBuilder, config)))
+            {
+                // Act
+                var swaggerDocument = await httpClient.GetJsonAsync<SwaggerDocument>("swagger/docs/v1");
+
+                // Assert
+                swaggerDocument.host.Should().Be("foo");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Tests/Fixtures/PatchTests.cs b/Swashbuckle.OData.Tests/Fixtures/PatchTests.cs
new file mode 100644
index 0000000..a6822ed
--- /dev/null
+++ b/Swashbuckle.OData.Tests/Fixtures/PatchTests.cs
@@ -0,0 +1,33 @@
+using System.Linq;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.Owin.Hosting;
+using NUnit.Framework;
+using Swashbuckle.OData.Tests.WebHost;
+using Swashbuckle.Swagger;
+
+namespace Swashbuckle.OData.Tests
+{
+    [TestFixture]
+    public class PatchTests
+    {
+        [Test]
+        public async Task It_has_a_body_parameter_with_a_schema()
+        {
+            using (WebApp.Start(TestWebApiStartup.BaseAddress, appBuilder => new TestWebApiStartup().Configuration(appBuilder)))
+            {
+                // Arrange
+                var httpClient = HttpClientUtils.GetHttpClient();
+
+                // Act
+                var swaggerDocument = await httpClient.GetJsonAsync<SwaggerDocument>("swagger/docs/v1");
+
+                // Assert
+                PathItem pathItem;
+                swaggerDocument.paths.TryGetValue("/Orders({OrderId})", out pathItem);
+                pathItem.patch.parameters.Single(parameter => parameter.@in == "body").schema.Should().NotBeNull();
+                pathItem.patch.parameters.Single(parameter => parameter.@in == "body").schema.@ref.Should().Be("#/definitions/Order");
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Tests/GetQueryParametersTests.cs b/Swashbuckle.OData.Tests/Fixtures/PostTests.cs
similarity index 52%
rename from Swashbuckle.OData.Tests/GetQueryParametersTests.cs
rename to Swashbuckle.OData.Tests/Fixtures/PostTests.cs
index a18944e..5f1b2a3 100644
--- a/Swashbuckle.OData.Tests/GetQueryParametersTests.cs
+++ b/Swashbuckle.OData.Tests/Fixtures/PostTests.cs
@@ -1,5 +1,4 @@
-using System.Linq;
-using System.Threading.Tasks;
+using System.Threading.Tasks;
 using FluentAssertions;
 using Microsoft.Owin.Hosting;
 using NUnit.Framework;
@@ -9,10 +8,10 @@
 namespace Swashbuckle.OData.Tests
 {
     [TestFixture]
-    public class GetQueryParametersTests
+    public class PostTests
     {
         [Test]
-        public async Task It_includes_the_filter_parameter()
+        public async Task It_has_a_summary()
         {
             using (WebApp.Start(TestWebApiStartup.BaseAddress, appBuilder => new TestWebApiStartup().Configuration(appBuilder)))
             {
@@ -20,17 +19,14 @@ public async Task It_includes_the_filter_parameter()
                 var httpClient = HttpClientUtils.GetHttpClient();
 
                 // Act
-                var swaggerDocument = await httpClient.GetAsync<SwaggerDocument>("swagger/docs/v1");
+                var swaggerDocument = await httpClient.GetJsonAsync<SwaggerDocument>("swagger/docs/v1");
 
                 // Assert
                 PathItem pathItem;
                 swaggerDocument.paths.TryGetValue("/Customers", out pathItem);
                 pathItem.Should().NotBeNull();
-                var filterParameter = pathItem.get.parameters.SingleOrDefault(parameter => parameter.name == "$filter");
-                filterParameter.Should().NotBeNull();
-                filterParameter.description.Should().NotBeNullOrWhiteSpace();
-                filterParameter.type.ShouldBeEquivalentTo("string");
-                filterParameter.@in.ShouldBeEquivalentTo("query");
+                pathItem.post.Should().NotBeNull();
+                pathItem.post.summary.Should().NotBeNullOrWhiteSpace();
             }
         }
     }
diff --git a/Swashbuckle.OData.Tests/Fixtures/PutTests.cs b/Swashbuckle.OData.Tests/Fixtures/PutTests.cs
new file mode 100644
index 0000000..62ee9d4
--- /dev/null
+++ b/Swashbuckle.OData.Tests/Fixtures/PutTests.cs
@@ -0,0 +1,52 @@
+using System.Linq;
+using System.Threading.Tasks;
+using FluentAssertions;
+using Microsoft.Owin.Hosting;
+using NUnit.Framework;
+using Swashbuckle.OData.Tests.WebHost;
+using Swashbuckle.Swagger;
+
+namespace Swashbuckle.OData.Tests
+{
+    [TestFixture]
+    public class PutTests
+    {
+        [Test]
+        public async Task It_includes_a_put_operation()
+        {
+            using (WebApp.Start(TestWebApiStartup.BaseAddress, appBuilder => new TestWebApiStartup().Configuration(appBuilder)))
+            {
+                // Arrange
+                var httpClient = HttpClientUtils.GetHttpClient();
+
+                // Act
+                var swaggerDocument = await httpClient.GetJsonAsync<SwaggerDocument>("swagger/docs/v1");
+
+                // Assert
+                PathItem pathItem;
+                swaggerDocument.paths.TryGetValue("/Customers({Id})", out pathItem);
+                pathItem.Should().NotBeNull();
+                pathItem.put.Should().NotBeNull();
+            }
+        }
+
+        [Test]
+        public async Task It_does_not_exist_if_not_in_the_controller()
+        {
+            using (WebApp.Start(TestWebApiStartup.BaseAddress, appBuilder => new TestWebApiStartup().Configuration(appBuilder)))
+            {
+                // Arrange
+                var httpClient = HttpClientUtils.GetHttpClient();
+
+                // Act
+                var swaggerDocument = await httpClient.GetJsonAsync<SwaggerDocument>("swagger/docs/v1");
+
+                // Assert
+                PathItem pathItem;
+                swaggerDocument.paths.TryGetValue("/Orders({OrderId})", out pathItem);
+                pathItem.Should().NotBeNull();
+                pathItem.put.Should().BeNull();
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Tests/HttpClientUtils.cs b/Swashbuckle.OData.Tests/HttpClientUtils.cs
index 1a2a717..3f15e86 100644
--- a/Swashbuckle.OData.Tests/HttpClientUtils.cs
+++ b/Swashbuckle.OData.Tests/HttpClientUtils.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Net.Http;
+using System.Net.Http.Headers;
 using Flurl;
 using Swashbuckle.OData.Tests.WebHost;
 using SwashbuckleODataSample;
@@ -10,11 +11,16 @@ public class HttpClientUtils
     {
         public static HttpClient GetHttpClient()
         {
-            return new HttpClient
+            var client =  new HttpClient
             {
                 BaseAddress = new Uri(TestWebApiStartup.BaseAddress.AppendPathSegment(WebApiConfig.ODataRoutePrefix)),
                 Timeout = TimeSpan.FromMilliseconds(5 * 60 * 1000)
             };
+
+            client.DefaultRequestHeaders.Accept.Clear();
+            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue(ContentType.ApplicationJson));
+
+            return client;
         }
     }
 }
\ No newline at end of file
diff --git a/Swashbuckle.OData.Tests/HttpExtensions.cs b/Swashbuckle.OData.Tests/HttpExtensions.cs
index f7df894..e8a2f08 100644
--- a/Swashbuckle.OData.Tests/HttpExtensions.cs
+++ b/Swashbuckle.OData.Tests/HttpExtensions.cs
@@ -5,6 +5,8 @@
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 
 namespace Swashbuckle.OData.Tests
 {
@@ -46,13 +48,24 @@ public static async Task<T> GetAsync<T>(this HttpClient client)
         /// <param name="client">The client used to make the request.</param>
         /// <param name="requestUri">The Uri the request is sent to.</param><exception cref="T:System.ArgumentNullException">The <paramref name="requestUri"/> was null.</exception>
         /// <returns>The content deserialized as type T</returns>
-        public static async Task<T> GetAsync<T>(this HttpClient client, string requestUri)
+        public static async Task<T> GetJsonAsync<T>(this HttpClient client, string requestUri)
         {
             var response = await client.GetAsync(requestUri);
 
             await response.ValidateSuccessAsync();
 
-            return await response.Content.ReadAsAsync<T>();
+            var serializerSettings = new JsonSerializerSettings
+            {
+                ContractResolver = new CamelCasePropertyNamesContractResolver(),
+                NullValueHandling = NullValueHandling.Ignore,
+                DateFormatHandling = DateFormatHandling.IsoDateFormat,
+                DateTimeZoneHandling = DateTimeZoneHandling.Utc,
+                MetadataPropertyHandling = MetadataPropertyHandling.Ignore
+            };
+
+            var responseJsonString = await response.Content.ReadAsStringAsync();
+
+            return JsonConvert.DeserializeObject<T>(responseJsonString, serializerSettings);
         }
 
         #endregion
diff --git a/Swashbuckle.OData.Tests/Order.cs b/Swashbuckle.OData.Tests/Order.cs
deleted file mode 100644
index 3aacd0d..0000000
--- a/Swashbuckle.OData.Tests/Order.cs
+++ /dev/null
@@ -1,21 +0,0 @@
-using System.ComponentModel.DataAnnotations;
-using System.ComponentModel.DataAnnotations.Schema;
-using System.Web.OData.Builder;
-using Microsoft.OData.Edm;
-
-namespace Swashbuckle.OData.Tests
-{
-    public class Order
-    {
-        [Key]
-        public int OrderId { get; set; }
-
-        public string OrderName { get; set; }
-
-        public int CustomerId { get; set; }
-
-        [ForeignKey("CustomerId")]
-        [ActionOnDelete(EdmOnDeleteAction.Cascade)]
-        public Customer Customer { get; set; }
-    }
-}
\ No newline at end of file
diff --git a/Swashbuckle.OData.Tests/Swashbuckle.OData.Tests.csproj b/Swashbuckle.OData.Tests/Swashbuckle.OData.Tests.csproj
index 3a37b1d..07bb38e 100644
--- a/Swashbuckle.OData.Tests/Swashbuckle.OData.Tests.csproj
+++ b/Swashbuckle.OData.Tests/Swashbuckle.OData.Tests.csproj
@@ -112,11 +112,15 @@
     <Reference Include="System.Xml.Linq" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Customer.cs" />
+    <Compile Include="ApplyDocumentVendorExtensions.cs" />
+    <Compile Include="ContentType.cs" />
+    <Compile Include="Fixtures\ODataSwaggerProviderTests.cs" />
+    <Compile Include="Fixtures\PostTests.cs" />
+    <Compile Include="Fixtures\PatchTests.cs" />
+    <Compile Include="Fixtures\PutTests.cs" />
     <Compile Include="HttpClientUtils.cs" />
-    <Compile Include="HttpConfigurationRoutesTests.cs" />
-    <Compile Include="Order.cs" />
-    <Compile Include="GetQueryParametersTests.cs" />
+    <Compile Include="Fixtures\HttpConfigurationRoutesTests.cs" />
+    <Compile Include="Fixtures\GetTests.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
     <Compile Include="HttpExtensions.cs" />
     <Compile Include="WebHost\TestWebApiStartup.cs" />
diff --git a/Swashbuckle.OData.Tests/WebHost/TestWebApiStartup.cs b/Swashbuckle.OData.Tests/WebHost/TestWebApiStartup.cs
index 1410051..1943854 100644
--- a/Swashbuckle.OData.Tests/WebHost/TestWebApiStartup.cs
+++ b/Swashbuckle.OData.Tests/WebHost/TestWebApiStartup.cs
@@ -1,4 +1,5 @@
-using System.Web.Http;
+using System;
+using System.Web.Http;
 using Owin;
 using Swashbuckle.Application;
 using SwashbuckleODataSample;
@@ -10,15 +11,17 @@ public class TestWebApiStartup
         public const string BaseAddress = "http://localhost:8347/";
 
         /// <summary>
-        /// This code configures Web API. 
+        /// This code configures Web API.
         /// The TestWebApiStartup class is specified as a type parameter in the WebApp.Start method.
         /// </summary>
         /// <param name="appBuilder">The application builder.</param>
-        public void Configuration(IAppBuilder appBuilder)
+        /// <param name="unitTestConfigs">Additional unit test configurations.</param>
+        public void Configuration(IAppBuilder appBuilder, Action<SwaggerDocsConfig> unitTestConfigs = null)
         {
             var httpConfiguration = new HttpConfiguration();
 
             WebApiConfig.Register(httpConfiguration);
+            FormatterConfig.Register(httpConfiguration);
 
             httpConfiguration
                 .EnableSwagger(c =>
@@ -33,12 +36,12 @@ public void Configuration(IAppBuilder appBuilder)
                     // alternative implementation for ISwaggerProvider with the CustomProvider option.
                     //
                     c.CustomProvider(defaultProvider => new ODataSwaggerProvider(defaultProvider, c, () => httpConfiguration));
+
+                    unitTestConfigs?.Invoke(c);
                 })
                 .EnableSwaggerUi();
 
             appBuilder.UseWebApi(httpConfiguration);
-
-            httpConfiguration.EnsureInitialized();
         }
     }
 }
\ No newline at end of file
diff --git a/Swashbuckle.OData.sln b/Swashbuckle.OData.sln
index 5ed5b10..b94b2c0 100644
--- a/Swashbuckle.OData.sln
+++ b/Swashbuckle.OData.sln
@@ -1,7 +1,7 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
 # Visual Studio 14
-VisualStudioVersion = 14.0.23107.0
+VisualStudioVersion = 14.0.24720.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FF286327-C783-4F7A-AB73-9BCBAD0D4460}") = "Swashbuckle.OData.NuGet", "Swashbuckle.OData.Nuget\Swashbuckle.OData.NuGet.nuproj", "{5CD33FC5-9E4C-48E3-A69D-EF5F0BAC2162}"
 EndProject
@@ -9,6 +9,7 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Swashbuckle.OData", "Swashb
 EndProject
 Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{EF4A9CB1-3309-4630-9980-10A5E11D4101}"
 	ProjectSection(SolutionItems) = preProject
+		License.txt = License.txt
 		README.md = README.md
 	EndProjectSection
 EndProject
diff --git a/Swashbuckle.OData/CollectionExtentions.cs b/Swashbuckle.OData/CollectionExtentions.cs
new file mode 100644
index 0000000..39a9fe3
--- /dev/null
+++ b/Swashbuckle.OData/CollectionExtentions.cs
@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics.Contracts;
+
+namespace Swashbuckle.OData
+{
+    public static class CollectionExtentions
+    {
+        /// <summary>
+        /// Adds the elements of the specified collection to the end of the <see cref="Collection{T}"/>.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="source">The source collection.</param>
+        /// <param name="collection">
+        /// The collection whose elements should be added to the end of the <see cref="Collection{T}"/>. 
+        /// The collection itself cannot be null, but it can contain elements that are null, if type T is a reference type.
+        /// </param>
+        public static void AddRange<T>(this Collection<T> source, IEnumerable<T> collection)
+        {
+            Contract.Requires(source != null);
+            Contract.Requires(collection != null);
+
+            foreach (var item in collection)
+            {
+                source.Add(item);
+            }
+        }
+
+        /// <summary>
+        /// Adds the given item to the collection if the item is not null.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="source">The source.</param>
+        /// <param name="item">The item.</param>
+        public static void AddIfNotNull<T>(this Collection<T> source, T item)
+        {
+            Contract.Requires(source != null);
+
+            if (item != null)
+            {
+                source.Add(item);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData/Descriptions/IParameterMapper.cs b/Swashbuckle.OData/Descriptions/IParameterMapper.cs
new file mode 100644
index 0000000..cf750fb
--- /dev/null
+++ b/Swashbuckle.OData/Descriptions/IParameterMapper.cs
@@ -0,0 +1,114 @@
+using System;
+using System.Linq;
+using System.Web.Http.Controllers;
+using Swashbuckle.Swagger;
+
+namespace Swashbuckle.OData
+{
+    public interface IParameterMapper
+    {
+        HttpParameterDescriptor Map(Parameter parameter, int index, HttpActionDescriptor actionDescriptor);
+    }
+
+    public class MapByParameterName : IParameterMapper
+    {
+        public HttpParameterDescriptor Map(Parameter parameter, int index, HttpActionDescriptor actionDescriptor)
+        {
+            return actionDescriptor.GetParameters()
+                .SingleOrDefault(descriptor => string.Equals(descriptor.ParameterName, parameter.name, StringComparison.CurrentCultureIgnoreCase));
+        }
+    }
+
+    public class MapByDescription : IParameterMapper
+    {
+        public HttpParameterDescriptor Map(Parameter parameter, int index, HttpActionDescriptor actionDescriptor)
+        {
+            // Maybe the parameter is a key parameter, e.g., where Id in the URI path maps to a parameter named 'key'
+            if (parameter.description.StartsWith("key:"))
+            {
+                var parameterDescriptor = actionDescriptor.GetParameters().SingleOrDefault(descriptor => descriptor.ParameterName == "key");
+                if (parameterDescriptor != null)
+                {
+                    // Need to assign the correct name expected by OData
+                    return new ODataParameterDescriptor(parameter.name, parameterDescriptor.ParameterType, parameterDescriptor.IsOptional)
+                    {
+                        Configuration = actionDescriptor.ControllerDescriptor.Configuration,
+                        ActionDescriptor = actionDescriptor,
+                        ParameterBinderAttribute = parameterDescriptor.ParameterBinderAttribute
+                    };
+                }
+            }
+            return null;
+        }
+    }
+
+    public class MapByIndex : IParameterMapper
+    {
+        public HttpParameterDescriptor Map(Parameter parameter, int index, HttpActionDescriptor actionDescriptor)
+        {
+            if (parameter.@in != "query" && index < actionDescriptor.GetParameters().Count)
+            {
+                var parameterDescriptor = actionDescriptor.GetParameters()[index];
+                if (parameterDescriptor != null)
+                {
+                    // Need to assign the correct name expected by OData
+                    return new ODataParameterDescriptor(parameter.name, parameterDescriptor.ParameterType, parameterDescriptor.IsOptional)
+                    {
+                        Configuration = actionDescriptor.ControllerDescriptor.Configuration,
+                        ActionDescriptor = actionDescriptor,
+                        ParameterBinderAttribute = parameterDescriptor.ParameterBinderAttribute
+                    };
+                }
+            }
+            return null;
+        }
+    }
+
+    public class MapToDefault : IParameterMapper
+    {
+        public HttpParameterDescriptor Map(Parameter parameter, int index, HttpActionDescriptor actionDescriptor)
+        {
+            return new ODataParameterDescriptor(parameter.name, GetType(parameter), !parameter.required.Value)
+            {
+                Configuration = actionDescriptor.ControllerDescriptor.Configuration,
+                ActionDescriptor = actionDescriptor
+            };
+        }
+
+        private static Type GetType(Parameter queryParameter)
+        {
+            var type = queryParameter.type;
+            var format = queryParameter.format;
+
+            switch (format)
+            {
+                case null:
+                    switch (type)
+                    {
+                        case "string":
+                            return typeof(string);
+                        case "boolean":
+                            return typeof(bool);
+                        default:
+                            throw new Exception(string.Format("Could not determine .NET type for parameter type {0} and format {1}", type, "null"));
+                    }
+                case "int32":
+                    return typeof(int);
+                case "int64":
+                    return typeof(long);
+                case "byte":
+                    return typeof(byte);
+                case "date":
+                    return typeof(DateTime);
+                case "date-time":
+                    return typeof(DateTimeOffset);
+                case "double":
+                    return typeof(double);
+                case "float":
+                    return typeof(float);
+                default:
+                    throw new Exception(string.Format("Could not determine .NET type for parameter type {0} and format {1}", type, format));
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData/Descriptions/ODataApiExplorer.cs b/Swashbuckle.OData/Descriptions/ODataApiExplorer.cs
new file mode 100644
index 0000000..5c0e78f
--- /dev/null
+++ b/Swashbuckle.OData/Descriptions/ODataApiExplorer.cs
@@ -0,0 +1,412 @@
+using System;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Linq;
+using System.Net.Http;
+using System.Net.Http.Formatting;
+using System.Web.Http;
+using System.Web.Http.Controllers;
+using System.Web.Http.Description;
+using System.Web.Http.Routing;
+using System.Web.Http.Services;
+using System.Web.OData.Formatter;
+using System.Web.OData.Routing;
+using Microsoft.OData.Edm;
+using Swashbuckle.Swagger;
+
+namespace Swashbuckle.OData
+{
+    public class ODataApiExplorer : IApiExplorer
+    {
+        private const string ServiceRoot = "http://any/";
+        private readonly Lazy<Collection<ApiDescription>> _apiDescriptions;
+        private readonly Func<HttpConfiguration> _config;
+        private readonly SwaggerToApiExplorerMapper _swaggerToApiExplorerMapper;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ODataApiExplorer" /> class.
+        /// </summary>
+        /// <param name="httpConfigurationProvider">The HTTP configuration provider.</param>
+        public ODataApiExplorer(Func<HttpConfiguration> httpConfigurationProvider)
+        {
+            _config = httpConfigurationProvider;
+            _apiDescriptions = new Lazy<Collection<ApiDescription>>(GetApiDescriptions);
+            _swaggerToApiExplorerMapper = GetSwaggerToApiExplorerMapper();
+        }
+
+        private static SwaggerToApiExplorerMapper GetSwaggerToApiExplorerMapper()
+        {
+            var parameterMappers = new List<IParameterMapper>
+            {
+                new MapByParameterName(),
+                new MapByDescription(),
+                new MapByIndex(),
+                new MapToDefault()
+            };
+
+            return new SwaggerToApiExplorerMapper(parameterMappers);
+        }
+
+        /// <summary>
+        ///     Gets the API descriptions. The descriptions are initialized on the first access.
+        /// </summary>
+        public Collection<ApiDescription> ApiDescriptions
+        {
+            get { return _apiDescriptions.Value; }
+        }
+
+        private Collection<ApiDescription> GetApiDescriptions()
+        {
+            var apiDescriptions = new Collection<ApiDescription>();
+
+            foreach (var odataRoute in FlattenRoutes(_config().Routes).OfType<ODataRoute>())
+            {
+                apiDescriptions.AddRange(GetApiDescriptions(odataRoute));
+            }
+
+            return apiDescriptions;
+        }
+
+        /// <summary>
+        ///     Explores the route.
+        /// </summary>
+        /// <param name="oDataRoute">The route.</param>
+        /// <returns></returns>
+        private Collection<ApiDescription> GetApiDescriptions(ODataRoute oDataRoute)
+        {
+            var apiDescriptions = new Collection<ApiDescription>();
+
+            foreach (var potentialPathTemplateAndOperations in GetDefaultEdmSwaggerDocument(oDataRoute).paths)
+            {
+                apiDescriptions.AddRange(GetApiDescriptions(oDataRoute, potentialPathTemplateAndOperations.Key, potentialPathTemplateAndOperations.Value));
+            }
+
+            return apiDescriptions;
+        }
+
+        private Collection<ApiDescription> GetApiDescriptions(ODataRoute oDataRoute, string potentialPathTemplate, PathItem potentialOperations)
+        {
+            var apiDescriptions = new Collection<ApiDescription>();
+
+            apiDescriptions.AddIfNotNull(GetApiDescription(new HttpMethod("DELETE"), oDataRoute, potentialPathTemplate, potentialOperations.delete));
+            apiDescriptions.AddIfNotNull(GetApiDescription(new HttpMethod("GET"), oDataRoute, potentialPathTemplate, potentialOperations.get));
+            apiDescriptions.AddIfNotNull(GetApiDescription(new HttpMethod("POST"), oDataRoute, potentialPathTemplate, potentialOperations.post));
+            apiDescriptions.AddIfNotNull(GetApiDescription(new HttpMethod("PUT"), oDataRoute, potentialPathTemplate, potentialOperations.put));
+            apiDescriptions.AddIfNotNull(GetApiDescription(new HttpMethod("PATCH"), oDataRoute, potentialPathTemplate, potentialOperations.patch));
+
+            return apiDescriptions;
+        }
+
+        private ApiDescription GetApiDescription(HttpMethod httpMethod, ODataRoute oDataRoute, string potentialPathTemplate, Operation potentialOperation)
+        {
+            if (potentialOperation != null)
+            {
+                var odataPath = GenerateSampleODataPath(oDataRoute, potentialPathTemplate, potentialOperation);
+
+                var httpControllerDescriptor = GetControllerDesciptor(oDataRoute, odataPath);
+
+                if (httpControllerDescriptor != null)
+                {
+                    var oDataPathRouteConstraint = GetODataPathRouteConstraint(oDataRoute);
+
+                    var controllerContext = new HttpControllerContext
+                    {
+                        Request = new HttpRequestMessage(httpMethod, ServiceRoot),
+                        RouteData = new HttpRouteData(new HttpRoute())
+                    };
+
+                    var actionMappings = _config().Services.GetActionSelector().GetActionMapping(httpControllerDescriptor);
+
+                    var action = GetActionName(oDataPathRouteConstraint, odataPath, controllerContext, actionMappings);
+
+                    if (action != null)
+                    {
+                        return GetApiDescription(actionMappings[action].First(), httpMethod, potentialOperation, oDataRoute, potentialPathTemplate);
+                    }
+                }
+            }
+
+            return null;
+        }
+
+        private ApiDescription GetApiDescription(HttpActionDescriptor actionDescriptor, HttpMethod httpMethod, Operation operation, ODataRoute route, string potentialPathTemplate)
+        {
+            var apiDocumentation = GetApiDocumentation(actionDescriptor, operation);
+
+            var parameterDescriptions = CreateParameterDescriptions(operation, actionDescriptor);
+
+            // request formatters
+            var bodyParameter = parameterDescriptions.FirstOrDefault(description => description.SwaggerSource == SwaggerApiParameterSource.Body);
+            var supportedRequestBodyFormatters = bodyParameter != null 
+                ? actionDescriptor.Configuration.Formatters.Where(f => f is ODataMediaTypeFormatter && f.CanReadType(bodyParameter.ParameterDescriptor.ParameterType)) 
+                : Enumerable.Empty<MediaTypeFormatter>();
+
+            // response formatters
+            var responseDescription = CreateResponseDescription(actionDescriptor);
+            var returnType = responseDescription.ResponseType ?? responseDescription.DeclaredType;
+            var supportedResponseFormatters = returnType != null && returnType != typeof (void) 
+                ? actionDescriptor.Configuration.Formatters.Where(f => f is ODataMediaTypeFormatter && f.CanWriteType(returnType)) 
+                : Enumerable.Empty<MediaTypeFormatter>();
+
+            // Replacing the formatter tracers with formatters if tracers are present.
+            supportedRequestBodyFormatters = GetInnerFormatters(supportedRequestBodyFormatters);
+            supportedResponseFormatters = GetInnerFormatters(supportedResponseFormatters);
+
+            var apiDescription =  new ApiDescription
+            {
+                Documentation = apiDocumentation,
+                HttpMethod = httpMethod,
+                RelativePath = potentialPathTemplate.TrimStart('/'),
+                ActionDescriptor = actionDescriptor,
+                Route = route
+            };
+
+            apiDescription.SupportedResponseFormatters.AddRange(supportedResponseFormatters);
+            apiDescription.SupportedRequestBodyFormatters.AddRange(supportedRequestBodyFormatters.ToList());
+            apiDescription.ParameterDescriptions.AddRange(parameterDescriptions);
+
+            // Have to set ResponseDescription because it's internal!??
+            apiDescription.GetType().GetProperty("ResponseDescription").SetValue(apiDescription, responseDescription);
+
+            return apiDescription;
+        }
+
+        private static IEnumerable<MediaTypeFormatter> GetInnerFormatters(IEnumerable<MediaTypeFormatter> mediaTypeFormatters)
+        {
+            return mediaTypeFormatters.Select(Decorator.GetInner);
+        }
+
+        private static ResponseDescription CreateResponseDescription(HttpActionDescriptor actionDescriptor)
+        {
+            var responseTypeAttribute = actionDescriptor.GetCustomAttributes<ResponseTypeAttribute>();
+            var responseType = responseTypeAttribute.Select(attribute => attribute.ResponseType).FirstOrDefault();
+
+            return new ResponseDescription
+            {
+                DeclaredType = actionDescriptor.ReturnType,
+                ResponseType = responseType,
+                Documentation = GetApiResponseDocumentation(actionDescriptor)
+            };
+        }
+
+        private static string GetApiResponseDocumentation(HttpActionDescriptor actionDescriptor)
+        {
+            var documentationProvider = actionDescriptor.Configuration.Services.GetDocumentationProvider();
+            return documentationProvider?.GetResponseDocumentation(actionDescriptor);
+        }
+
+        private List<SwaggerApiParameterDescription> CreateParameterDescriptions(Operation operation, HttpActionDescriptor actionDescriptor)
+        {
+            return operation.parameters.Select((parameter, index) => GetParameterDescription(parameter, index, actionDescriptor)).ToList();
+        }
+
+        private SwaggerApiParameterDescription GetParameterDescription(Parameter parameter, int index, HttpActionDescriptor actionDescriptor)
+        {
+            var httpParameterDescriptor = GetHttpParameterDescriptor(parameter, index, actionDescriptor);
+
+            return new SwaggerApiParameterDescription
+            {
+                ParameterDescriptor = httpParameterDescriptor,
+                Name = httpParameterDescriptor.Prefix ?? httpParameterDescriptor.ParameterName,
+                Documentation = GetApiParameterDocumentation(parameter, httpParameterDescriptor),
+                SwaggerSource = MapSource(parameter)
+            };
+        }
+
+        private static SwaggerApiParameterSource MapSource(Parameter parameter)
+        {
+            switch (parameter.@in)
+            {
+                case "query":
+                    return SwaggerApiParameterSource.Query;
+                case "header":
+                    return SwaggerApiParameterSource.Header;
+                case "path":
+                    return SwaggerApiParameterSource.Path;
+                case "formData":
+                    return SwaggerApiParameterSource.FormData;
+                case "body":
+                    return SwaggerApiParameterSource.Body;
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(parameter), parameter, null);
+            }
+        }
+
+        private HttpParameterDescriptor GetHttpParameterDescriptor(Parameter parameter, int index, HttpActionDescriptor actionDescriptor)
+        {
+            return _swaggerToApiExplorerMapper.Map(parameter, index, actionDescriptor);
+        }
+
+        private static string GetApiParameterDocumentation(Parameter parameter, HttpParameterDescriptor parameterDescriptor)
+        {
+            var documentationProvider = parameterDescriptor.Configuration.Services.GetDocumentationProvider();
+
+            return documentationProvider != null 
+                ? documentationProvider.GetDocumentation(parameterDescriptor) 
+                : parameter.description;
+        }
+
+        private static string GetApiDocumentation(HttpActionDescriptor actionDescriptor, Operation operation)
+        {
+            var documentationProvider = actionDescriptor.Configuration.Services.GetDocumentationProvider();
+            return documentationProvider != null 
+                ? documentationProvider.GetDocumentation(actionDescriptor) 
+                : operation.description;
+        }
+
+        private static ODataPath GenerateSampleODataPath(ODataRoute oDataRoute, string pathTemplate, Operation operation)
+        {
+            var sampleODataPathString = GenerateSampleODataPathString(pathTemplate, operation);
+
+            var oDataPathRouteConstraint = GetODataPathRouteConstraint(oDataRoute);
+
+            var model = GetEdmModel(oDataRoute);
+
+            return oDataPathRouteConstraint.PathHandler.Parse(model, ServiceRoot, sampleODataPathString);
+        }
+
+        private static string GenerateSampleODataPathString(string pathTemplate, Operation operation)
+        {
+            var uriTemplate = new UriTemplate(pathTemplate);
+
+            var parameters = GenerateSampleQueryParameterValues(operation);
+
+            var prefix = new Uri(ServiceRoot);
+
+            return uriTemplate.BindByName(prefix, parameters).ToString();
+        }
+
+        private static IDictionary<string, string> GenerateSampleQueryParameterValues(Operation operation)
+        {
+            return operation.parameters.Where(parameter => parameter.@in == "path").ToDictionary(queryParameter => queryParameter.name, GenerateSampleQueryParameterValue);
+        }
+
+        private static string GenerateSampleQueryParameterValue(Parameter queryParameter)
+        {
+            var type = queryParameter.type;
+            var format = queryParameter.format;
+
+            switch (format)
+            {
+                case null:
+                    switch (type)
+                    {
+                        case "string":
+                            return "SampleString";
+                        case "boolean":
+                            return "true";
+                        default:
+                            throw new Exception(string.Format("Could not generate sample value for query parameter type {0} and format {1}", type, "null"));
+                    }
+                case "int32":
+                case "int64":
+                    return "42";
+                case "byte":
+                    return "1";
+                case "date":
+                    return "2015-12-12T12:00";
+                case "date-time":
+                    return "2015-10-10T17:00:00Z";
+                case "double":
+                    return "2.34d";
+                case "float":
+                    return "2.0f";
+                default:
+                    throw new Exception(string.Format("Could not generate sample value for query parameter type {0} and format {1}", type, format));
+            }
+        }
+
+        private HttpControllerDescriptor GetControllerDesciptor(ODataRoute oDataRoute, ODataPath potentialPath)
+        {
+            var oDataPathRouteConstraint = GetODataPathRouteConstraint(oDataRoute);
+
+            var controllerName = GetControllerName(oDataPathRouteConstraint, potentialPath);
+
+            var controllerMappings = _config().Services.GetHttpControllerSelector().GetControllerMapping();
+
+            HttpControllerDescriptor controllerDescriptor = null;
+            if (controllerName != null && controllerMappings != null)
+            {
+                controllerMappings.TryGetValue(controllerName, out controllerDescriptor);
+            }
+            return controllerDescriptor;
+        }
+
+        /// <summary>
+        ///     Selects the name of the controller to dispatch the request to.
+        /// </summary>
+        /// <param name="oDataPathRouteConstraint">The o data path route constraint.</param>
+        /// <param name="path">The OData path of the request.</param>
+        /// <returns>
+        ///     The name of the controller to dispatch to, or <c>null</c> if one cannot be resolved.
+        /// </returns>
+        private static string GetControllerName(ODataPathRouteConstraint oDataPathRouteConstraint, ODataPath path)
+        {
+            return oDataPathRouteConstraint.RoutingConventions
+                .Select(routingConvention => routingConvention.SelectController(path, new HttpRequestMessage()))
+                .FirstOrDefault(controllerName => controllerName != null);
+        }
+
+        private static string GetActionName(ODataPathRouteConstraint oDataPathRouteConstraint, ODataPath path, HttpControllerContext controllerContext, ILookup<string, HttpActionDescriptor> actionMap)
+        {
+            return oDataPathRouteConstraint.RoutingConventions.Select(routingConvention => routingConvention.SelectAction(path, controllerContext, actionMap)).FirstOrDefault(action => action != null);
+        }
+
+        public static string FindMatchingAction(ILookup<string, HttpActionDescriptor> actionMap, params string[] targetActionNames)
+        {
+            return targetActionNames.FirstOrDefault(actionMap.Contains);
+        }
+
+        private static SwaggerDocument GetDefaultEdmSwaggerDocument(ODataRoute oDataRoute)
+        {
+            return new ODataSwaggerConverter(GetEdmModel(oDataRoute)).ConvertToSwaggerModel();
+        }
+
+        private static IEdmModel GetEdmModel(ODataRoute oDataRoute)
+        {
+            return GetODataPathRouteConstraint(oDataRoute).EdmModel;
+        }
+
+        private static ODataPathRouteConstraint GetODataPathRouteConstraint(ODataRoute oDataRoute)
+        {
+            return oDataRoute.Constraints.Values.SingleOrDefault(value => value is ODataPathRouteConstraint) as ODataPathRouteConstraint;
+        }
+
+        private static IEnumerable<IHttpRoute> FlattenRoutes(IEnumerable<IHttpRoute> routes)
+        {
+            foreach (var route in routes)
+            {
+                var nested = route as IEnumerable<IHttpRoute>;
+                if (nested != null)
+                {
+                    foreach (var subRoute in FlattenRoutes(nested))
+                    {
+                        yield return subRoute;
+                    }
+                }
+                else
+                {
+                    yield return route;
+                }
+            }
+        }
+    }
+
+    internal class ODataParameterDescriptor : HttpParameterDescriptor
+    {
+        public ODataParameterDescriptor(string parameterName, Type parameterType, bool isOptional)
+        {
+            ParameterName = parameterName;
+            ParameterType = parameterType;
+            IsOptional = isOptional;
+        }
+
+        public override string ParameterName { get; }
+
+        public override Type ParameterType { get; }
+
+        public override bool IsOptional { get; }
+
+
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData/Descriptions/SwaggerToApiExplorerMapper.cs b/Swashbuckle.OData/Descriptions/SwaggerToApiExplorerMapper.cs
new file mode 100644
index 0000000..443e754
--- /dev/null
+++ b/Swashbuckle.OData/Descriptions/SwaggerToApiExplorerMapper.cs
@@ -0,0 +1,27 @@
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Linq;
+using System.Web.Http.Controllers;
+using Swashbuckle.Swagger;
+
+namespace Swashbuckle.OData
+{
+    public class SwaggerToApiExplorerMapper
+    {
+        private readonly IEnumerable<IParameterMapper> _parameterMappers;
+
+        public SwaggerToApiExplorerMapper(IEnumerable<IParameterMapper> parameterMappers)
+        {
+            Contract.Requires(parameterMappers != null);
+
+            _parameterMappers = parameterMappers;
+        }
+
+        public HttpParameterDescriptor Map(Parameter parameter, int index, HttpActionDescriptor actionDescriptor)
+        {
+            return _parameterMappers
+                .Select(mapper => mapper.Map(parameter, index, actionDescriptor))
+                .FirstOrDefault(httpParameterDescriptor => httpParameterDescriptor != null);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData/HttpConfigurationExtensions.cs b/Swashbuckle.OData/HttpConfigurationExtensions.cs
new file mode 100644
index 0000000..91fecbb
--- /dev/null
+++ b/Swashbuckle.OData/HttpConfigurationExtensions.cs
@@ -0,0 +1,16 @@
+using System.Web.Http;
+using Newtonsoft.Json;
+
+namespace Swashbuckle.OData
+{
+    public static class HttpConfigurationExtensions
+    {
+        internal static JsonSerializerSettings SerializerSettingsOrDefault(this HttpConfiguration httpConfig)
+        {
+            var formatter = httpConfig.Formatters.JsonFormatter;
+            return formatter != null 
+                ? formatter.SerializerSettings 
+                : new JsonSerializerSettings();
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData/ODataSwaggerConverter.cs b/Swashbuckle.OData/ODataSwaggerConverter.cs
index 1fb124c..93eae11 100644
--- a/Swashbuckle.OData/ODataSwaggerConverter.cs
+++ b/Swashbuckle.OData/ODataSwaggerConverter.cs
@@ -137,10 +137,19 @@ protected virtual void InitializeDocument()
                     version = "0.1.0"
                 },
                 host = Host,
-                schemes = new List<string> { "http" },
+                schemes = new List<string>
+                {
+                    "http"
+                },
                 basePath = BasePath,
-                consumes = new List<string> { "application/json" },
-                produces = new List<string> { "application/json" }
+                consumes = new List<string>
+                {
+                    "application/json"
+                },
+                produces = new List<string>
+                {
+                    "application/json"
+                }
             };
         }
 
diff --git a/Swashbuckle.OData/ODataSwaggerProvider.cs b/Swashbuckle.OData/ODataSwaggerProvider.cs
index 0f468ac..a325100 100644
--- a/Swashbuckle.OData/ODataSwaggerProvider.cs
+++ b/Swashbuckle.OData/ODataSwaggerProvider.cs
@@ -1,9 +1,11 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics.Contracts;
 using System.Linq;
 using System.Web.Http;
+using System.Web.Http.Description;
+using System.Web.OData;
 using System.Web.OData.Routing;
-using Flurl;
 using Swashbuckle.Application;
 using Swashbuckle.Swagger;
 
@@ -11,71 +13,268 @@ namespace Swashbuckle.OData
 {
     public class ODataSwaggerProvider : ISwaggerProvider
     {
-        private readonly ISwaggerProvider _defaultProvider;
-        // Here for future use against the OData API...
-        private readonly SwaggerDocsConfig _swaggerDocsConfig;
+        private readonly IApiExplorer _apiExplorer;
+        private readonly IDictionary<string, Info> _apiVersions;
+        private readonly SwaggerGeneratorOptions _options;
+
         private readonly Func<HttpConfiguration> _httpConfigurationProvider;
+        private readonly ISwaggerProvider _defaultProvider;
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="ODataSwaggerProvider" /> class.
+        ///     Initializes a new instance of the <see cref="ODataSwaggerProvider" /> class.
         /// </summary>
         /// <param name="defaultProvider">The default provider.</param>
         /// <param name="swaggerDocsConfig">The swagger docs configuration.</param>
-        public ODataSwaggerProvider(ISwaggerProvider defaultProvider, SwaggerDocsConfig swaggerDocsConfig) 
-            : this(defaultProvider, swaggerDocsConfig, () => GlobalConfiguration.Configuration)
+        public ODataSwaggerProvider(ISwaggerProvider defaultProvider, SwaggerDocsConfig swaggerDocsConfig) : this(defaultProvider, swaggerDocsConfig, () => GlobalConfiguration.Configuration)
         {
             Contract.Requires(defaultProvider != null);
             Contract.Requires(swaggerDocsConfig != null);
         }
 
         /// <summary>
-        /// Initializes a new instance of the <see cref="ODataSwaggerProvider" /> class.
-        /// Use this constructor for self-hosted scenarios.
+        ///     Initializes a new instance of the <see cref="ODataSwaggerProvider" /> class.
+        ///     Use this constructor for self-hosted scenarios.
         /// </summary>
         /// <param name="defaultProvider">The default provider.</param>
         /// <param name="swaggerDocsConfig">The swagger docs configuration.</param>
-        /// <param name="httpConfigurationProvider">A function that will return the HttpConfiguration that contains the OData Edm Model.</param>
+        /// <param name="httpConfigurationProvider">
+        ///     A function that will return the HttpConfiguration that contains the OData Edm
+        ///     Model.
+        /// </param>
         public ODataSwaggerProvider(ISwaggerProvider defaultProvider, SwaggerDocsConfig swaggerDocsConfig, Func<HttpConfiguration> httpConfigurationProvider)
         {
             Contract.Requires(defaultProvider != null);
             Contract.Requires(swaggerDocsConfig != null);
             Contract.Requires(httpConfigurationProvider != null);
 
+            _apiExplorer = new ODataApiExplorer(httpConfigurationProvider);
+            _apiVersions = GetApiVersions(defaultProvider);
             _defaultProvider = defaultProvider;
-            _swaggerDocsConfig = swaggerDocsConfig;
             _httpConfigurationProvider = httpConfigurationProvider;
+            _options = GetSwaggerGeneratorOptions(defaultProvider);
+        }
+
+        /// <summary>
+        /// Gets the API versions. I'd rather not use reflection because the implementation may change, but can't find a better way.
+        /// </summary>
+        /// <param name="defaultProvider">The default provider.</param>
+        /// <returns></returns>
+        private static IDictionary<string, Info> GetApiVersions(ISwaggerProvider defaultProvider)
+        {
+            var swaggerGenerator = defaultProvider as SwaggerGenerator;
+            Contract.Assert(swaggerGenerator != null, "The ODataSwaggerProvider currently requires a defaultProvider of type SwaggerGenerator");
+            var apiVersions = typeof(SwaggerGenerator).GetInstanceField(swaggerGenerator, "_apiVersions") as IDictionary<string, Info>;
+            Contract.Assert(apiVersions != null, "The ODataSwaggerProvider currently requires that the SwaggerGenerator has a non-null field '_apiVersions' of type SwaggerGeneratorOptions");
+            return apiVersions;
+        }
+
+        /// <summary>
+        /// Gets the swagger generator options via Reflection. I'd rather not use reflection because the implementation may change, but can't find a better way.
+        /// </summary>
+        /// <param name="defaultProvider">The default provider.</param>
+        private static SwaggerGeneratorOptions GetSwaggerGeneratorOptions(ISwaggerProvider defaultProvider)
+        {
+            var swaggerGenerator = defaultProvider as SwaggerGenerator;
+            Contract.Assert(swaggerGenerator != null, "The ODataSwaggerProvider currently requires a defaultProvider of type SwaggerGenerator");
+            var options = typeof (SwaggerGenerator).GetInstanceField(swaggerGenerator, "_options") as SwaggerGeneratorOptions;
+            Contract.Assert(options != null, "The ODataSwaggerProvider currently requires that the SwaggerGenerator has a non-null field '_options' of type SwaggerGeneratorOptions");
+            return options;
         }
 
         public SwaggerDocument GetSwagger(string rootUrl, string apiVersion)
         {
+            var schemaRegistry = GetSchemaRegistry();
+
+            Info info;
+            _apiVersions.TryGetValue(apiVersion, out info);
+            if (info == null)
+                throw new UnknownApiVersion(apiVersion);
+
+            var paths = GetApiDescriptionsFor(apiVersion)
+                .Where(apiDesc => !(_options.IgnoreObsoleteActions && apiDesc.IsObsolete()))
+                .OrderBy(_options.GroupingKeySelector, _options.GroupingKeyComparer)
+                .GroupBy(apiDesc => apiDesc.RelativePathSansQueryString())
+                .ToDictionary(group => "/" + group.Key, group => CreatePathItem(group, schemaRegistry));
+
             var oDataRoute = _httpConfigurationProvider().Routes.SingleOrDefault(route => route is ODataRoute) as ODataRoute;
 
             if (oDataRoute != null)
             {
-                var oDataPathRouteConstraint = oDataRoute.Constraints.Values.SingleOrDefault(value => value is ODataPathRouteConstraint) as ODataPathRouteConstraint;
-
-                var edmModel = oDataPathRouteConstraint.EdmModel;
                 var routePrefix = oDataRoute.RoutePrefix;
 
-                var oDataSwaggerConverter = new ODataSwaggerConverter(edmModel);
-
                 var rootUri = new Uri(rootUrl);
+                var port = !rootUri.IsDefaultPort ? ":" + rootUri.Port : string.Empty;
 
-                var basePath = rootUri.AbsolutePath != "/" ? rootUri.AbsolutePath : "/" + routePrefix;
+                var swaggerDoc = new SwaggerDocument
+                {
+                    info = info,
+                    host = rootUri.Host + port,
+                    basePath = rootUri.AbsolutePath != "/" ? rootUri.AbsolutePath : "/" + routePrefix,
+                    schemes = _options.Schemes?.ToList() ?? new[] { rootUri.Scheme }.ToList(),
+                    paths = paths,
+                    definitions = schemaRegistry.Definitions,
+                    securityDefinitions = _options.SecurityDefinitions
+                };
 
-                oDataSwaggerConverter.MetadataUri = new Uri(rootUrl.AppendPathSegments(basePath, "$metadata"));
+                foreach (var filter in _options.DocumentFilters)
+                {
+                    filter.Apply(swaggerDoc, schemaRegistry, _apiExplorer);
+                }
 
-                var port = !rootUri.IsDefaultPort ? ":" + rootUri.Port : string.Empty;
+                return swaggerDoc;
+            }
+
+            return _defaultProvider.GetSwagger(rootUrl, apiVersion);
+        }
+
+        private SchemaRegistry GetSchemaRegistry()
+        {
+            return new SchemaRegistry(
+                _httpConfigurationProvider().SerializerSettingsOrDefault(), 
+                _options.CustomSchemaMappings, _options.SchemaFilters, 
+                _options.ModelFilters, 
+                _options.IgnoreObsoleteProperties, 
+                _options.SchemaIdSelector, 
+                _options.DescribeAllEnumsAsStrings, 
+                _options.DescribeStringEnumsInCamelCase);
+        }
+
+        private PathItem CreatePathItem(IEnumerable<ApiDescription> apiDescriptions, SchemaRegistry schemaRegistry)
+        {
+            var pathItem = new PathItem();
+
+            // Group further by http method
+            var perMethodGrouping = apiDescriptions
+                .GroupBy(apiDesc => apiDesc.HttpMethod.Method.ToLower());
 
-                var edmSwaggerDocument = oDataSwaggerConverter.ConvertToSwaggerModel();
-                edmSwaggerDocument.host = rootUri.Host + port;
-                edmSwaggerDocument.basePath = basePath;
-                edmSwaggerDocument.schemes = new[] { rootUri.Scheme }.ToList();
+            foreach (var group in perMethodGrouping)
+            {
+                var httpMethod = group.Key;
+
+                var apiDescription = (group.Count() == 1)
+                    ? group.First()
+                    : _options.ConflictingActionsResolver(group);
 
-                return edmSwaggerDocument;
+                switch (httpMethod)
+                {
+                    case "get":
+                        pathItem.get = CreateOperation(apiDescription, schemaRegistry);
+                        break;
+                    case "put":
+                        pathItem.put = CreateOperation(apiDescription, schemaRegistry);
+                        break;
+                    case "post":
+                        pathItem.post = CreateOperation(apiDescription, schemaRegistry);
+                        break;
+                    case "delete":
+                        pathItem.delete = CreateOperation(apiDescription, schemaRegistry);
+                        break;
+                    case "options":
+                        pathItem.options = CreateOperation(apiDescription, schemaRegistry);
+                        break;
+                    case "head":
+                        pathItem.head = CreateOperation(apiDescription, schemaRegistry);
+                        break;
+                    case "patch":
+                        pathItem.patch = CreateOperation(apiDescription, schemaRegistry);
+                        break;
+                }
             }
 
-            return _defaultProvider.GetSwagger(rootUrl, apiVersion);
+            return pathItem;
+        }
+
+        private Operation CreateOperation(ApiDescription apiDescription, SchemaRegistry schemaRegistry)
+        {
+            var parameters = apiDescription.ParameterDescriptions
+                .Select(paramDesc =>
+                {
+                    var inPath = apiDescription.RelativePathSansQueryString().Contains("{" + paramDesc.Name + "}");
+                    return CreateParameter(paramDesc as SwaggerApiParameterDescription, inPath, schemaRegistry);
+                })
+                 .ToList();
+
+            var responses = new Dictionary<string, Response>();
+            var responseType = apiDescription.ResponseType();
+            if (responseType == null || responseType == typeof(void))
+                responses.Add("204", new Response { description = "No Content" });
+            else
+                responses.Add("200", new Response { description = "OK", schema = schemaRegistry.GetOrRegisterODataType(responseType) });
+
+            var operation = new Operation
+            {
+                summary = apiDescription.Documentation,
+                tags = new[] { _options.GroupingKeySelector(apiDescription) },
+                operationId = apiDescription.FriendlyId(),
+                produces = apiDescription.Produces().ToList(),
+                consumes = apiDescription.Consumes().ToList(),
+                parameters = parameters.Any() ? parameters : null, // parameters can be null but not empty
+                responses = responses,
+                deprecated = apiDescription.IsObsolete()
+            };
+
+            foreach (var filter in _options.OperationFilters)
+            {
+                filter.Apply(operation, schemaRegistry, apiDescription);
+            }
+
+            return operation;
+        }
+
+        private static Parameter CreateParameter(SwaggerApiParameterDescription paramDesc, bool inPath, SchemaRegistry schemaRegistry)
+        {
+            var @in = inPath
+                ? "path"
+                : MapToSwaggerParameterLocation(paramDesc.SwaggerSource);
+
+            var parameter = new Parameter
+            {
+                name = paramDesc.Name,
+                description = paramDesc.Documentation,
+                @in = @in
+            };
+
+            if (paramDesc.ParameterDescriptor == null)
+            {
+                parameter.type = "string";
+                parameter.required = true;
+                return parameter;
+            }
+
+            parameter.required = inPath || !paramDesc.ParameterDescriptor.IsOptional;
+            parameter.@default = paramDesc.ParameterDescriptor.DefaultValue;
+
+            var schema = schemaRegistry.GetOrRegisterODataType(paramDesc.ParameterDescriptor.ParameterType);
+            if (parameter.@in == "body")
+                parameter.schema = schema;
+            else
+                parameter.PopulateFrom(schema);
+
+            return parameter;
+        }
+
+        private static string MapToSwaggerParameterLocation(SwaggerApiParameterSource swaggerSource)
+        {
+            switch (swaggerSource)
+            {
+                case SwaggerApiParameterSource.Query:
+                    return "query";
+                case SwaggerApiParameterSource.Header:
+                    return "header";
+                case SwaggerApiParameterSource.Path:
+                    return "path";
+                case SwaggerApiParameterSource.FormData:
+                    return "formData";
+                case SwaggerApiParameterSource.Body:
+                    return "body";
+                default:
+                    throw new ArgumentOutOfRangeException(nameof(swaggerSource), swaggerSource, null);
+            }
+        }
+
+        private IEnumerable<ApiDescription> GetApiDescriptionsFor(string apiVersion)
+        {
+            return _options.VersionSupportResolver == null ? _apiExplorer.ApiDescriptions : _apiExplorer.ApiDescriptions.Where(apiDesc => _options.VersionSupportResolver(apiDesc, apiVersion));
         }
     }
 }
\ No newline at end of file
diff --git a/Swashbuckle.OData/ODataSwaggerUtilities.cs b/Swashbuckle.OData/ODataSwaggerUtilities.cs
index 7ddf96e..1f1bf93 100644
--- a/Swashbuckle.OData/ODataSwaggerUtilities.cs
+++ b/Swashbuckle.OData/ODataSwaggerUtilities.cs
@@ -8,6 +8,7 @@
 using System.Linq;
 using Microsoft.OData.Edm;
 using Newtonsoft.Json;
+using Newtonsoft.Json.Serialization;
 using Swashbuckle.Swagger;
 
 namespace Swashbuckle.OData
@@ -34,29 +35,25 @@ public static PathItem CreateSwaggerPathForEntitySet(IEdmNavigationSource naviga
             return new PathItem
             {
                 get = new Operation()
-                    .Summary("Get EntitySet " + entitySet.Name)
-                    .OperationId(entitySet.Name + "_Get")
-                    .Description("Returns the EntitySet " + entitySet.Name)
-                    .Tags(entitySet.Name)
-                    .Parameters(new List<Parameter>()
-                        .Parameter("$expand", "query", "Expands related entities inline.", "string")
-                        .Parameter("$filter", "query", "Filters the results, based on a Boolean condition.", "string")
-                        .Parameter("$select", "query", "Selects which properties to include in the response.", "string")
-                        .Parameter("$orderby", "query", "Sorts the results.", "string")
-                        .Parameter("$top", "query", "Returns only the first n results.", "integer")
-                        .Parameter("$skip", "query", "Skips the first n results.", "integer")
-                        .Parameter("$count", "query", "Includes a count of the matching results in the reponse.", "boolean"))
-                    .Responses(new Dictionary<string, Response>().Response("200", "EntitySet " + entitySet.Name, entitySet.EntityType())
-                        .DefaultErrorResponse()),
+                .Summary("Get EntitySet " + entitySet.Name)
+                .OperationId(entitySet.Name + "_Get")
+                .Description("Returns the EntitySet " + entitySet.Name)
+                .Tags(entitySet.Name)
+                .Parameters(new List<Parameter>().Parameter("$expand", "query", "Expands related entities inline.", "string", false)
+                .Parameter("$filter", "query", "Filters the results, based on a Boolean condition.", "string", false)
+                .Parameter("$select", "query", "Selects which properties to include in the response.", "string", false)
+                .Parameter("$orderby", "query", "Sorts the results.", "string", false)
+                .Parameter("$top", "query", "Returns only the first n results.", "integer", false, "int32")
+                .Parameter("$skip", "query", "Skips the first n results.", "integer", false, "int32")
+                .Parameter("$count", "query", "Includes a count of the matching results in the reponse.", "boolean", false))
+                .Responses(new Dictionary<string, Response>().Response("200", "EntitySet " + entitySet.Name, entitySet.EntityType()).DefaultErrorResponse()),
                 post = new Operation()
-                    .Summary("Post a new entity to EntitySet " + entitySet.Name)
-                    .OperationId(entitySet.Name + "_Post")
-                    .Description("Post a new entity to EntitySet " + entitySet.Name)
-                    .Tags(entitySet.Name)
-                    .Parameters(new List<Parameter>().Parameter(entitySet.EntityType()
-                        .Name, "body", "The entity to post", entitySet.EntityType()))
-                    .Responses(new Dictionary<string, Response>().Response("200", "EntitySet " + entitySet.Name, entitySet.EntityType())
-                        .DefaultErrorResponse())
+                .Summary("Post a new entity to EntitySet " + entitySet.Name)
+                .OperationId(entitySet.Name + "_Post")
+                .Description("Post a new entity to EntitySet " + entitySet.Name)
+                .Tags(entitySet.Name).Parameters(new List<Parameter>()
+                .Parameter(entitySet.EntityType().Name, "body", "The entity to post", entitySet.EntityType()))
+                .Responses(new Dictionary<string, Response>().Response("200", "EntitySet " + entitySet.Name, entitySet.EntityType()).DefaultErrorResponse())
             };
         }
 
@@ -74,43 +71,47 @@ public static PathItem CreateSwaggerPathForEntity(IEdmNavigationSource navigatio
             }
 
             var keyParameters = new List<Parameter>();
-            foreach (var key in entitySet.EntityType()
-                .Key())
+            foreach (var key in entitySet.EntityType().Key())
             {
                 string format;
                 var type = GetPrimitiveTypeAndFormat(key.Type.Definition as IEdmPrimitiveType, out format);
-                keyParameters.Parameter(key.Name, "path", "key: " + key.Name, type, format);
+                keyParameters.Parameter(key.Name, "path", "key: " + key.Name, type, true, format);
             }
 
             return new PathItem
             {
                 get = new Operation()
-                    .Summary("Get entity from " + entitySet.Name + " by key.")
-                    .OperationId(entitySet.Name + "_GetById")
-                    .Description("Returns the entity with the key from " + entitySet.Name)
-                    .Tags(entitySet.Name)
-                    .Parameters(keyParameters.DeepClone().Parameter("$expand", "query", "Expands related entities inline.", "string"))
-                    .Parameters(keyParameters.DeepClone().Parameter("$select", "query", "Selects which properties to include in the response.", "string"))
-                    .Responses(new Dictionary<string, Response>().Response("200", "EntitySet " + entitySet.Name, entitySet.EntityType())
-                        .DefaultErrorResponse()),
+                .Summary("Get entity from " + entitySet.Name + " by key.")
+                .OperationId(entitySet.Name + "_GetById")
+                .Description("Returns the entity with the key from " + entitySet.Name)
+                .Tags(entitySet.Name).Parameters(keyParameters.DeepClone()
+                .Parameter("$expand", "query", "Expands related entities inline.", "string", false))
+                .Parameters(keyParameters.DeepClone().Parameter("$select", "query", "Selects which properties to include in the response.", "string", false))
+                .Responses(new Dictionary<string, Response>().Response("200", "EntitySet " + entitySet.Name, entitySet.EntityType()).DefaultErrorResponse()),
+
                 patch = new Operation()
-                    .Summary("Update entity in EntitySet " + entitySet.Name)
-                    .OperationId(entitySet.Name + "_PatchById")
-                    .Description("Update entity in EntitySet " + entitySet.Name)
-                    .Tags(entitySet.Name)
-                    .Parameters(keyParameters.DeepClone().Parameter(entitySet.EntityType()
-                        .Name, "body", "The entity to patch", entitySet.EntityType()))
-                    .Responses(new Dictionary<string, Response>().Response("204", "Empty response")
-                        .DefaultErrorResponse()),
-                delete = new Operation()
-                    .Summary("Delete entity in EntitySet " + entitySet.Name)
-                    .OperationId(entitySet.Name + "_DeleteById")
-                    .Description("Delete entity in EntitySet " + entitySet.Name)
-                    .Tags(entitySet.Name)
-                    .Parameters(keyParameters.DeepClone().Parameter("If-Match", "header", "If-Match header", "string"))
-                    .Responses(new Dictionary<string, Response>()
-                        .Response("204", "Empty response")
-                        .DefaultErrorResponse())
+                .Summary("Update entity in EntitySet " + entitySet.Name)
+                .OperationId(entitySet.Name + "_PatchById")
+                .Description("Update entity in EntitySet " + entitySet.Name)
+                .Tags(entitySet.Name)
+                .Parameters(keyParameters.DeepClone().Parameter(entitySet.EntityType().Name, "body", "The entity to patch", entitySet.EntityType()))
+                .Responses(new Dictionary<string, Response>()
+                .Response("204", "Empty response").DefaultErrorResponse()),
+
+                put = new Operation()
+                .Summary("Replace entity in EntitySet " + entitySet.Name)
+                .OperationId(entitySet.Name + "_PutById")
+                .Description("Replace entity in EntitySet " + entitySet.Name)
+                .Tags(entitySet.Name)
+                .Parameters(keyParameters.DeepClone().Parameter(entitySet.EntityType().Name, "body", "The entity to put", entitySet.EntityType()))
+                .Responses(new Dictionary<string, Response>().Response("204", "Empty response").DefaultErrorResponse()),
+
+                delete = new Operation().Summary("Delete entity in EntitySet " + entitySet.Name)
+                .OperationId(entitySet.Name + "_DeleteById")
+                .Description("Delete entity in EntitySet " + entitySet.Name)
+                .Tags(entitySet.Name)
+                .Parameters(keyParameters.DeepClone().Parameter("If-Match", "header", "If-Match header", "string", false))
+                .Responses(new Dictionary<string, Response>().Response("204", "Empty response").DefaultErrorResponse())
             };
         }
 
@@ -143,10 +144,7 @@ public static PathItem CreateSwaggerPathForOperationImport(IEdmOperationImport o
                 swaggerResponses.Response("200", "Response from " + operationImport.Name, operationImport.Operation.ReturnType.Definition);
             }
 
-            var swaggerOperationImport = new Operation().Summary("Call operation import  " + operationImport.Name)
-                .OperationId(operationImport.Name + (isFunctionImport ? "_FunctionImportGet" : "_ActionImportPost"))
-                .Description("Call operation import  " + operationImport.Name)
-                .Tags(isFunctionImport ? "Function Import" : "Action Import");
+            var swaggerOperationImport = new Operation().Summary("Call operation import  " + operationImport.Name).OperationId(operationImport.Name + (isFunctionImport ? "_FunctionImportGet" : "_ActionImportPost")).Description("Call operation import  " + operationImport.Name).Tags(isFunctionImport ? "Function Import" : "Action Import");
 
             if (swaggerParameters.Count > 0)
             {
@@ -154,15 +152,13 @@ public static PathItem CreateSwaggerPathForOperationImport(IEdmOperationImport o
             }
             swaggerOperationImport.Responses(swaggerResponses.DefaultErrorResponse());
 
-            return isFunctionImport 
-                ? new PathItem
-                {
-                    get = swaggerOperationImport
-                } 
-                : new PathItem
-                {
-                    post = swaggerOperationImport
-                };
+            return isFunctionImport ? new PathItem
+            {
+                get = swaggerOperationImport
+            } : new PathItem
+            {
+                post = swaggerOperationImport
+            };
         }
 
         /// <summary>
@@ -199,12 +195,7 @@ public static PathItem CreateSwaggerPathForOperationOfEntitySet(IEdmOperation op
                 swaggerResponses.Response("200", "Response from " + operation.Name, operation.ReturnType.Definition);
             }
 
-            var swaggerOperation = new Operation()
-                .Summary("Call operation  " + operation.Name)
-                .OperationId(operation.Name + (isFunction ? "_FunctionGet" : "_ActionPost"))
-                .Description("Call operation  " + operation.Name)
-                .OperationId(operation.Name + (isFunction ? "_FunctionGetById" : "_ActionPostById"))
-                .Tags(entitySet.Name, isFunction ? "Function" : "Action");
+            var swaggerOperation = new Operation().Summary("Call operation  " + operation.Name).OperationId(operation.Name + (isFunction ? "_FunctionGet" : "_ActionPost")).Description("Call operation  " + operation.Name).OperationId(operation.Name + (isFunction ? "_FunctionGetById" : "_ActionPostById")).Tags(entitySet.Name, isFunction ? "Function" : "Action");
 
             if (swaggerParameters.Count > 0)
             {
@@ -212,15 +203,13 @@ public static PathItem CreateSwaggerPathForOperationOfEntitySet(IEdmOperation op
             }
             swaggerOperation.Responses(swaggerResponses.DefaultErrorResponse());
 
-            return isFunction
-                ? new PathItem
-                {
-                    get = swaggerOperation
-                }
-                : new PathItem
-                {
-                    post = swaggerOperation
-                };
+            return isFunction ? new PathItem
+            {
+                get = swaggerOperation
+            } : new PathItem
+            {
+                post = swaggerOperation
+            };
         }
 
         /// <summary>
@@ -240,12 +229,11 @@ public static PathItem CreateSwaggerPathForOperationOfEntity(IEdmOperation opera
             var isFunction = operation is IEdmFunction;
             var swaggerParameters = new List<Parameter>();
 
-            foreach (var key in entitySet.EntityType()
-                .Key())
+            foreach (var key in entitySet.EntityType().Key())
             {
                 string format;
                 var type = GetPrimitiveTypeAndFormat(key.Type.Definition as IEdmPrimitiveType, out format);
-                swaggerParameters.Parameter(key.Name, "path", "key: " + key.Name, type, format);
+                swaggerParameters.Parameter(key.Name, "path", "key: " + key.Name, type, true, format);
             }
 
             foreach (var parameter in operation.Parameters.Skip(1))
@@ -263,9 +251,7 @@ public static PathItem CreateSwaggerPathForOperationOfEntity(IEdmOperation opera
                 swaggerResponses.Response("200", "Response from " + operation.Name, operation.ReturnType.Definition);
             }
 
-            var swaggerOperation = new Operation().Summary("Call operation  " + operation.Name)
-                .Description("Call operation  " + operation.Name)
-                .Tags(entitySet.Name, isFunction ? "Function" : "Action");
+            var swaggerOperation = new Operation().Summary("Call operation  " + operation.Name).Description("Call operation  " + operation.Name).Tags(entitySet.Name, isFunction ? "Function" : "Action");
 
             if (swaggerParameters.Count > 0)
             {
@@ -273,15 +259,13 @@ public static PathItem CreateSwaggerPathForOperationOfEntity(IEdmOperation opera
             }
             swaggerOperation.Responses(swaggerResponses.DefaultErrorResponse());
 
-            return isFunction
-                ? new PathItem
-                {
-                    get = swaggerOperation
-                }
-                : new PathItem
-                {
-                    post = swaggerOperation
-                };
+            return isFunction ? new PathItem
+            {
+                get = swaggerOperation
+            } : new PathItem
+            {
+                post = swaggerOperation
+            };
         }
 
         /// <summary>
@@ -298,8 +282,7 @@ public static string GetPathForEntity(IEdmNavigationSource navigationSource)
             }
 
             var singleEntityPath = "/" + entitySet.Name + "(";
-            foreach (var key in entitySet.EntityType()
-                .Key())
+            foreach (var key in entitySet.EntityType().Key())
             {
                 if (key.Type.Definition.TypeKind == EdmTypeKind.Primitive && ((IEdmPrimitiveType) key.Type.Definition).PrimitiveKind == EdmPrimitiveTypeKind.String)
                 {
@@ -422,11 +405,11 @@ public static string GetPathForOperationOfEntity(IEdmOperation operation, IEdmNa
         }
 
         /// <summary>
-        /// Create the Swagger definition for the structure Edm type.
+        ///     Create the Swagger definition for the structure Edm type.
         /// </summary>
         /// <param name="edmType">The structure Edm type.</param>
         /// <returns>
-        /// The <see cref="Schema" /> represents the related structure Edm type.
+        ///     The <see cref="Schema" /> represents the related structure Edm type.
         /// </returns>
         public static Schema CreateSwaggerDefinitionForStructureType(IEdmStructuredType edmType)
         {
@@ -624,20 +607,22 @@ private static Operation Parameters(this Operation obj, IList<Parameter> paramet
             return obj;
         }
 
-        private static IList<Parameter> Parameter(this IList<Parameter> parameters, string name, string kind, string description, string type, string format = null)
+        private static IList<Parameter> Parameter(this IList<Parameter> parameters, string name, string kind, string description, string type, bool required, string format = null)
         {
             parameters.Add(new Parameter
             {
                 name = name,
                 @in = kind,
                 description = description,
-                type = type
+                type = type,
+                format = format,
+                required = required
             });
 
-            if (!string.IsNullOrEmpty(format))
-            {
-                parameters.First().format = format;
-            }
+            //if (!string.IsNullOrEmpty(format))
+            //{
+            //    parameters.First().format = format;
+            //}
 
             return parameters;
         }
@@ -696,18 +681,24 @@ private static Operation OperationId(this Operation obj, string operationId)
             return obj;
         }
 
-    /// <summary>
-    /// Perform a deep Copy of the object, using Json as a serialisation method.
-    /// </summary>
-    /// <typeparam name="T">The type of object being copied.</typeparam>
-    /// <param name="source">The object instance to copy.</param>
-    /// <returns>The copied object.</returns>
-    public static T DeepClone<T>(this T source)
+        /// <summary>
+        ///     Perform a deep Copy of the object, using Json as a serialisation method.
+        /// </summary>
+        /// <typeparam name="T">The type of object being copied.</typeparam>
+        /// <param name="source">The object instance to copy.</param>
+        /// <returns>The copied object.</returns>
+        public static T DeepClone<T>(this T source)
         {
+            var serializerSettings = new JsonSerializerSettings
+            {
+                ContractResolver = new CamelCasePropertyNamesContractResolver(),
+                NullValueHandling = NullValueHandling.Ignore,
+                DateFormatHandling = DateFormatHandling.IsoDateFormat,
+                DateTimeZoneHandling = DateTimeZoneHandling.Utc,
+                MetadataPropertyHandling = MetadataPropertyHandling.Ignore
+            };
             // Don't serialize a null object, simply return the default for that object
-            return ReferenceEquals(source, null) 
-                ? default(T) 
-                : JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source));
+            return ReferenceEquals(source, null) ? default(T) : JsonConvert.DeserializeObject<T>(JsonConvert.SerializeObject(source, serializerSettings), serializerSettings);
         }
     }
 }
\ No newline at end of file
diff --git a/Swashbuckle.OData/Properties/AssemblyInfo.cs b/Swashbuckle.OData/Properties/AssemblyInfo.cs
index e2aeae0..873bb73 100644
--- a/Swashbuckle.OData/Properties/AssemblyInfo.cs
+++ b/Swashbuckle.OData/Properties/AssemblyInfo.cs
@@ -4,6 +4,7 @@
 // General Information about an assembly is controlled through the following 
 // set of attributes. Change these attribute values to modify the information
 // associated with an assembly.
+
 [assembly: AssemblyTitle("Swashbuckle.OData")]
 [assembly: AssemblyDescription("")]
 [assembly: AssemblyConfiguration("")]
@@ -16,9 +17,11 @@
 // Setting ComVisible to false makes the types in this assembly not visible 
 // to COM components.  If you need to access a type in this assembly from 
 // COM, set the ComVisible attribute to true on that type.
+
 [assembly: ComVisible(false)]
 
 // The following GUID is for the ID of the typelib if this project is exposed to COM
+
 [assembly: Guid("aa7b6c37-092e-46ec-81a3-9865efd646f1")]
 
 // Version information for an assembly consists of the following four values:
@@ -31,6 +34,7 @@
 // You can specify all the values or you can default the Build and Revision Numbers 
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
+
 [assembly: AssemblyVersion("1.0.0.0")]
 [assembly: AssemblyFileVersion("1.0.0.0")]
-[assembly: AssemblyInformationalVersion("2.0.0")]
+[assembly: AssemblyInformationalVersion("2.1.0")]
\ No newline at end of file
diff --git a/Swashbuckle.OData/ReflectionExtensions.cs b/Swashbuckle.OData/ReflectionExtensions.cs
new file mode 100644
index 0000000..d49f371
--- /dev/null
+++ b/Swashbuckle.OData/ReflectionExtensions.cs
@@ -0,0 +1,22 @@
+using System;
+using System.Reflection;
+
+namespace Swashbuckle.OData
+{
+    public static class ReflectionExtensions
+    {
+        /// <summary>
+        ///     Uses reflection to get the field value from an object.
+        /// </summary>
+        /// <param name="type">The instance type.</param>
+        /// <param name="instance">The instance object.</param>
+        /// <param name="fieldName">The field's name which is to be fetched.</param>
+        /// <returns>The field value from the object.</returns>
+        internal static object GetInstanceField(this Type type, object instance, string fieldName)
+        {
+            const BindingFlags bindFlags = BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static;
+            var field = type.GetField(fieldName, bindFlags);
+            return field.GetValue(instance);
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData/SchemaRegistryExtensions.cs b/Swashbuckle.OData/SchemaRegistryExtensions.cs
new file mode 100644
index 0000000..d912116
--- /dev/null
+++ b/Swashbuckle.OData/SchemaRegistryExtensions.cs
@@ -0,0 +1,26 @@
+using System;
+using System.Web.Http;
+using System.Web.OData;
+using Swashbuckle.Swagger;
+
+namespace Swashbuckle.OData
+{
+    public static class SchemaRegistryExtensions
+    {
+        public static Schema GetOrRegisterODataType(this SchemaRegistry registry, Type type)
+        {
+            var isAGenericODataType = IsAGenericODataType(type);
+            return isAGenericODataType
+                ? registry.GetOrRegister(type.GetGenericArguments()[0]) 
+                : registry.GetOrRegister(type);
+        }
+
+        private static bool IsAGenericODataType(Type type)
+        {
+            var isDelta = type.IsGenericType && type.GetGenericTypeDefinition() == typeof (Delta<>);
+            var isSingleResult = type.IsGenericType && type.GetGenericTypeDefinition() == typeof (SingleResult<>);
+
+            return isDelta || isSingleResult;
+        }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData/SwaggerApiParameterDescription.cs b/Swashbuckle.OData/SwaggerApiParameterDescription.cs
new file mode 100644
index 0000000..ec27704
--- /dev/null
+++ b/Swashbuckle.OData/SwaggerApiParameterDescription.cs
@@ -0,0 +1,9 @@
+using System.Web.Http.Description;
+
+namespace Swashbuckle.OData
+{
+    public class SwaggerApiParameterDescription : ApiParameterDescription
+    {
+        public SwaggerApiParameterSource SwaggerSource { get; set; }
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData/SwaggerApiParameterSource.cs b/Swashbuckle.OData/SwaggerApiParameterSource.cs
new file mode 100644
index 0000000..7bd8075
--- /dev/null
+++ b/Swashbuckle.OData/SwaggerApiParameterSource.cs
@@ -0,0 +1,11 @@
+namespace Swashbuckle.OData
+{
+    public enum SwaggerApiParameterSource
+    {
+        Query,
+        Header,
+        Path,
+        FormData,
+        Body
+    }
+}
\ No newline at end of file
diff --git a/Swashbuckle.OData/Swashbuckle.OData.csproj b/Swashbuckle.OData/Swashbuckle.OData.csproj
index 536a0ad..7a6bb69 100644
--- a/Swashbuckle.OData/Swashbuckle.OData.csproj
+++ b/Swashbuckle.OData/Swashbuckle.OData.csproj
@@ -21,7 +21,7 @@
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
     <OutputPath>bin\Debug\</OutputPath>
-    <DefineConstants>TRACE;DEBUG;CONTRACTS_FULL</DefineConstants>
+    <DefineConstants>TRACE;DEBUG;CONTRACTS_FULL;ASPNETWEBAPI</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
@@ -73,7 +73,7 @@
     <DebugType>pdbonly</DebugType>
     <Optimize>true</Optimize>
     <OutputPath>bin\Release\</OutputPath>
-    <DefineConstants>TRACE;CONTRACTS_FULL</DefineConstants>
+    <DefineConstants>TRACE;CONTRACTS_FULL;ASPNETWEBAPI</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
     <CodeContractsEnableRuntimeChecking>True</CodeContractsEnableRuntimeChecking>
@@ -154,6 +154,7 @@
       <Private>True</Private>
     </Reference>
     <Reference Include="System.Net.Http.WebRequest" />
+    <Reference Include="System.ServiceModel" />
     <Reference Include="System.Web" />
     <Reference Include="System.Web.Http, Version=5.2.3.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35, processorArchitecture=MSIL">
       <HintPath>..\packages\Microsoft.AspNet.WebApi.Core.5.2.3\lib\net45\System.Web.Http.dll</HintPath>
@@ -169,14 +170,24 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CollectionExtentions.cs" />
+    <Compile Include="Descriptions\IParameterMapper.cs" />
+    <Compile Include="HttpConfigurationExtensions.cs" />
+    <Compile Include="Descriptions\SwaggerToApiExplorerMapper.cs" />
+    <Compile Include="Descriptions\ODataApiExplorer.cs" />
     <Compile Include="ODataSwaggerConverter.cs" />
     <Compile Include="ODataSwaggerProvider.cs" />
     <Compile Include="ODataSwaggerUtilities.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="ReflectionExtensions.cs" />
+    <Compile Include="SchemaRegistryExtensions.cs" />
+    <Compile Include="SwaggerApiParameterDescription.cs" />
+    <Compile Include="SwaggerApiParameterSource.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />
   </ItemGroup>
+  <ItemGroup />
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <Import Project="..\packages\NuProj.Common.0.10.4-beta\build\NuProj.Common.targets" Condition="Exists('..\packages\NuProj.Common.0.10.4-beta\build\NuProj.Common.targets')" />
   <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
diff --git a/Swashbuckle.OData/packages.config b/Swashbuckle.OData/packages.config
index 584c32d..d7a9d59 100644
--- a/Swashbuckle.OData/packages.config
+++ b/Swashbuckle.OData/packages.config
@@ -1,15 +1,16 @@
 <?xml version="1.0" encoding="utf-8"?>
+
 <packages>
-  <package id="Flurl" version="1.0.10" targetFramework="net452" />
-  <package id="Microsoft.AspNet.OData" version="5.7.0" targetFramework="net452" />
-  <package id="Microsoft.AspNet.WebApi.Client" version="5.2.3" targetFramework="net452" />
-  <package id="Microsoft.AspNet.WebApi.Core" version="5.2.3" targetFramework="net452" />
-  <package id="Microsoft.AspNet.WebApi.WebHost" version="5.2.3" targetFramework="net452" />
-  <package id="Microsoft.OData.Core" version="6.13.0" targetFramework="net452" />
-  <package id="Microsoft.OData.Edm" version="6.13.0" targetFramework="net452" />
-  <package id="Microsoft.Spatial" version="6.13.0" targetFramework="net452" />
-  <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net452" />
-  <package id="NuProj" version="0.10.4-beta-gf7fc34e7d8" targetFramework="net452" developmentDependency="true" />
-  <package id="NuProj.Common" version="0.10.4-beta" targetFramework="net452" developmentDependency="true" />
-  <package id="Swashbuckle.Core" version="5.2.2" targetFramework="net452" />
+    <package id="Flurl" version="1.0.10" targetFramework="net452" />
+    <package id="Microsoft.AspNet.OData" version="5.7.0" targetFramework="net452" />
+    <package id="Microsoft.AspNet.WebApi.Client" version="5.2.3" targetFramework="net452" />
+    <package id="Microsoft.AspNet.WebApi.Core" version="5.2.3" targetFramework="net452" />
+    <package id="Microsoft.AspNet.WebApi.WebHost" version="5.2.3" targetFramework="net452" />
+    <package id="Microsoft.OData.Core" version="6.13.0" targetFramework="net452" />
+    <package id="Microsoft.OData.Edm" version="6.13.0" targetFramework="net452" />
+    <package id="Microsoft.Spatial" version="6.13.0" targetFramework="net452" />
+    <package id="Newtonsoft.Json" version="7.0.1" targetFramework="net452" />
+    <package id="NuProj" version="0.10.4-beta-gf7fc34e7d8" targetFramework="net452" developmentDependency="true" />
+    <package id="NuProj.Common" version="0.10.4-beta" targetFramework="net452" developmentDependency="true" />
+    <package id="Swashbuckle.Core" version="5.2.2" targetFramework="net452" />
 </packages>
\ No newline at end of file