diff --git a/OneBus-Db.pdf b/OneBus-Db.pdf
index b38697c..26447ec 100644
Binary files a/OneBus-Db.pdf and b/OneBus-Db.pdf differ
diff --git a/OneBus.API/Controllers/LineAddressController.cs b/OneBus.API/Controllers/LineAddressController.cs
index fab0eac..de8593a 100644
--- a/OneBus.API/Controllers/LineAddressController.cs
+++ b/OneBus.API/Controllers/LineAddressController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.LineAddress;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.LineAddress;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Endereços da Linha")]
     public class LineAddressController : BaseController<LineAddress, CreateLineAddressDTO, ReadLineAddressDTO, UpdateLineAddressDTO, BaseFilter>
     {
         public LineAddressController(
@@ -12,5 +17,116 @@ public LineAddressController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar novo endereço de linha 
+        /// </summary>
+        /// <remarks>
+        /// POST de Endereço Linha
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar endereço de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Endereço de Linha cadastrado</returns>
+        /// <response code="200">Endereço de Linha cadastrado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineAddressDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineAddressDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateLineAddressDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar endereço de linha 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Endereço Linha
+        /// </remarks>
+        /// <param name="id">Id de endereço de linha</param>
+        /// <param name="updateDTO">Campos para atualizar endereço de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Endereço de Linha atualizado</returns>
+        /// <response code="200">Endereço de Linha atualizado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Endereço de Linha não encontrado</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineAddressDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineAddressDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineAddressDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadLineAddressDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateLineAddressDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar endereço de linha 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar endereço de linha 
+        /// </remarks>
+        /// <param name="id">Id de endereço de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Endereço de Linha habilitado</returns>
+        /// <response code="200">Endereço de Linha habilitado com sucesso</response>
+        /// <response code="404">Endereço de Linha não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar endereço de linha
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Endereço Linha 
+        /// </remarks>
+        /// <param name="id">Id de endereço de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Endereço de Linha deletado</returns>
+        /// <response code="200">Endereço de Linha deletado com sucesso</response>
+        /// <response code="404">Endereço de Linha não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter endereços de linha paginados e filtrados
+        /// </summary>
+        /// <remarks>
+        /// GET de Endereços Linha
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Endereços de Linha paginados e filtrados</returns>
+        /// <response code="200">Endereços de Linha paginados e filtrados com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadLineAddressDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter endereço de linha por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id de endereço de linha
+        /// </remarks>
+        /// <param name="id">Id de endereço de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Endereço de Linha encontrado</returns>
+        /// <response code="200">Endereço de Linha encontrado com sucesso</response>
+        /// <response code="404">Endereço de Linha não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineAddressDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineAddressDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/LineController.cs b/OneBus.API/Controllers/LineController.cs
index be2828d..dac4dcb 100644
--- a/OneBus.API/Controllers/LineController.cs
+++ b/OneBus.API/Controllers/LineController.cs
@@ -1,16 +1,132 @@
-using OneBus.Application.DTOs.Line;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.Line;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Linhas")]
     public class LineController : BaseController<Line, CreateLineDTO, ReadLineDTO, UpdateLineDTO, BaseFilter>
     {
         public LineController(
-            IBaseService<Line, CreateLineDTO, ReadLineDTO, UpdateLineDTO, BaseFilter> baseService) 
+            IBaseService<Line, CreateLineDTO, ReadLineDTO, UpdateLineDTO, BaseFilter> baseService)
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar nova linha 
+        /// </summary>
+        /// <remarks>
+        /// POST de Linha
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Linha cadastrada</returns>
+        /// <response code="200">Linha cadastrada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateLineDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar linha 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Linha
+        /// </remarks>
+        /// <param name="id">Id da linha</param>
+        /// <param name="updateDTO">Campos para atualizar linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Linha atualizada</returns>
+        /// <response code="200">Linha atualizada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Linha não encontrada</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadLineDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateLineDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar linha 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar linha 
+        /// </remarks>
+        /// <param name="id">Id da linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Linha habilitada</returns>
+        /// <response code="200">Linha habilitada com sucesso</response>
+        /// <response code="404">Linha não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar linha
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Linha 
+        /// </remarks>
+        /// <param name="id">Id da linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Linha deletada</returns>
+        /// <response code="200">Linha deletada com sucesso</response>
+        /// <response code="404">Linha não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter linhas paginadas e filtradas
+        /// </summary>
+        /// <remarks>
+        /// GET de Linhas
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Linhas paginadas e filtradas</returns>
+        /// <response code="200">Linhas paginadas e filtradas com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadLineDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter linha por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id da linha
+        /// </remarks>
+        /// <param name="id">Id da linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Linha encontrada</returns>
+        /// <response code="200">Linha encontrada com sucesso</response>
+        /// <response code="404">Linha não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/LineTariffAuditController.cs b/OneBus.API/Controllers/LineTariffAuditController.cs
index d5a047c..c5419dd 100644
--- a/OneBus.API/Controllers/LineTariffAuditController.cs
+++ b/OneBus.API/Controllers/LineTariffAuditController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.LineTariffAudit;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.LineTariffAudit;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Auditoria de Tarifas da Linha")]
     public class LineTariffAuditController : BaseController<LineTariffAudit, CreateLineTariffAuditDTO, ReadLineTariffAuditDTO, UpdateLineTariffAuditDTO, BaseFilter>
     {
         public LineTariffAuditController(
@@ -12,5 +17,116 @@ public LineTariffAuditController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar nova auditoria de tarifa de linha
+        /// </summary>
+        /// <remarks>
+        /// POST de Auditoria de Tarifa de Linha
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar auditoria de tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Auditoria de Tarifa de Linha cadastrada</returns>
+        /// <response code="200">Auditoria de Tarifa de Linha cadastrada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineTariffAuditDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineTariffAuditDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateLineTariffAuditDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar auditoria de tarifa de linha
+        /// </summary>
+        /// <remarks>
+        /// PUT de Auditoria de Tarifa de Linha
+        /// </remarks>
+        /// <param name="id">Id da auditoria de tarifa de linha</param>
+        /// <param name="updateDTO">Campos para atualizar auditoria de tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Auditoria de Tarifa de Linha atualizada</returns>
+        /// <response code="200">Auditoria de Tarifa de Linha atualizada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Auditoria de Tarifa de Linha não encontrada</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineTariffAuditDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineTariffAuditDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineTariffAuditDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadLineTariffAuditDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateLineTariffAuditDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar auditoria de tarifa de linha 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar auditoria de tarifa de linha
+        /// </remarks>
+        /// <param name="id">Id da auditoria de tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Auditoria de Tarifa de Linha habilitada</returns>
+        /// <response code="200">Auditoria de Tarifa de Linha habilitada com sucesso</response>
+        /// <response code="404">Auditoria de Tarifa de Linha não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar auditoria de tarifa de linha
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Auditoria de Tarifa de Linha 
+        /// </remarks>
+        /// <param name="id">Id da auditoria de tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Auditoria de Tarifa de Linha deletada</returns>
+        /// <response code="200">Auditoria de Tarifa de Linha deletada com sucesso</response>
+        /// <response code="404">Auditoria de Tarifa de Linha não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter auditoria de tarifas de linha paginadas e filtradas
+        /// </summary>
+        /// <remarks>
+        /// GET de Auditoria de Tarifas de Linha
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Auditoria de Tarifas de Linha paginadas e filtradas</returns>
+        /// <response code="200">Auditoria de Tarifas de Linha paginadas e filtradas com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadLineTariffAuditDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter auditoria de tarifa de linha por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id da auditoria de tarifa de linha
+        /// </remarks>
+        /// <param name="id">Id da auditoria de tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Auditoria de Tarifa de Linha encontrada</returns>
+        /// <response code="200">Auditoria de Tarifa de Linha encontrada com sucesso</response>
+        /// <response code="404">Auditoria de Tarifa de Linha não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineTariffAuditDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineTariffAuditDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/LineTariffController.cs b/OneBus.API/Controllers/LineTariffController.cs
index be05c36..e9e094e 100644
--- a/OneBus.API/Controllers/LineTariffController.cs
+++ b/OneBus.API/Controllers/LineTariffController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.LineTariff;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.LineTariff;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Tarifas da Linha")]
     public class LineTariffController : BaseController<LineTariff, CreateLineTariffDTO, ReadLineTariffDTO, UpdateLineTariffDTO, BaseFilter>
     {
         public LineTariffController(
@@ -12,5 +17,116 @@ public LineTariffController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar nova tarifa de linha 
+        /// </summary>
+        /// <remarks>
+        /// POST de Tarifa de Linha
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Tarifa de Linha cadastrada</returns>
+        /// <response code="200">Tarifa de Linha cadastrada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineTariffDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineTariffDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateLineTariffDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar tarifa de linha 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Tarifa de Linha
+        /// </remarks>
+        /// <param name="id">Id da tarifa de linha</param>
+        /// <param name="updateDTO">Campos para atualizar tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Tarifa de Linha atualizada</returns>
+        /// <response code="200">Tarifa de Linha atualizada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Tarifa de Linha não encontrada</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineTariffDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineTariffDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineTariffDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadLineTariffDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateLineTariffDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar tarifa de linha 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar tarifa de linha 
+        /// </remarks>
+        /// <param name="id">Id da tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Tarifa de Linha habilitada</returns>
+        /// <response code="200">Tarifa de Linha habilitada com sucesso</response>
+        /// <response code="404">Tarifa de Linha não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar tarifa de linha
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Tarifa de Linha 
+        /// </remarks>
+        /// <param name="id">Id da tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Tarifa de Linha deletada</returns>
+        /// <response code="200">Tarifa de Linha deletada com sucesso</response>
+        /// <response code="404">Tarifa de Linha não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter tarifas de linha paginadas e filtradas
+        /// </summary>
+        /// <remarks>
+        /// GET de Tarifas de Linha
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Tarifas de Linha paginadas e filtradas</returns>
+        /// <response code="200">Tarifas de Linha paginadas e filtradas com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadLineTariffDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter tarifa de linha por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id da tarifa de linha
+        /// </remarks>
+        /// <param name="id">Id da tarifa de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Tarifa de Linha encontrada</returns>
+        /// <response code="200">Tarifa de Linha encontrada com sucesso</response>
+        /// <response code="404">Tarifa de Linha não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineTariffDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineTariffDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/LineTimeController.cs b/OneBus.API/Controllers/LineTimeController.cs
index 550773e..1f38ae1 100644
--- a/OneBus.API/Controllers/LineTimeController.cs
+++ b/OneBus.API/Controllers/LineTimeController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.LineTime;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.LineTime;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Horários da Linha")]
     public class LineTimeController : BaseController<LineTime, CreateLineTimeDTO, ReadLineTimeDTO, UpdateLineTimeDTO, BaseFilter>
     {
         public LineTimeController(
@@ -12,5 +17,116 @@ public LineTimeController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar novo horário de linha 
+        /// </summary>
+        /// <remarks>
+        /// POST de Horário de Linha
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar horário de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Linha cadastrado</returns>
+        /// <response code="200">Horário de Linha cadastrado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineTimeDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineTimeDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateLineTimeDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar horário de linha 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Horário de Linha
+        /// </remarks>
+        /// <param name="id">Id do horário de linha</param>
+        /// <param name="updateDTO">Campos para atualizar horário de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Linha atualizado</returns>
+        /// <response code="200">Horário de Linha atualizado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Horário de Linha não encontrado</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineTimeDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadLineTimeDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineTimeDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadLineTimeDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateLineTimeDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar horário de linha 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar horário de linha 
+        /// </remarks>
+        /// <param name="id">Id do horário de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Linha habilitado</returns>
+        /// <response code="200">Horário de Linha habilitado com sucesso</response>
+        /// <response code="404">Horário de Linha não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar horário de linha
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Horário de Linha 
+        /// </remarks>
+        /// <param name="id">Id do horário de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Linha deletado</returns>
+        /// <response code="200">Horário de Linha deletado com sucesso</response>
+        /// <response code="404">Horário de Linha não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter horários de linha paginados e filtrados
+        /// </summary>
+        /// <remarks>
+        /// GET de Horários de Linha
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horários de Linha paginados e filtrados</returns>
+        /// <response code="200">Horários de Linha paginados e filtrados com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadLineTimeDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter horário de linha por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id do horário de linha
+        /// </remarks>
+        /// <param name="id">Id do horário de linha</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Linha encontrado</returns>
+        /// <response code="200">Horário de Linha encontrado com sucesso</response>
+        /// <response code="404">Horário de Linha não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadLineTimeDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadLineTimeDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/MaintenanceController.cs b/OneBus.API/Controllers/MaintenanceController.cs
index 0c35d8c..eac1847 100644
--- a/OneBus.API/Controllers/MaintenanceController.cs
+++ b/OneBus.API/Controllers/MaintenanceController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.Maintenance;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.Maintenance;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Manutenções")]
     public class MaintenanceController : BaseController<Maintenance, CreateMaintenanceDTO, ReadMaintenanceDTO, UpdateMaintenanceDTO, BaseFilter>
     {
         public MaintenanceController(
@@ -12,5 +17,116 @@ public MaintenanceController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar nova manutenção 
+        /// </summary>
+        /// <remarks>
+        /// POST de Manutenção
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar manutenção</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Manutenção cadastrada</returns>
+        /// <response code="200">Manutenção cadastrada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadMaintenanceDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadMaintenanceDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateMaintenanceDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar manutenção 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Manutenção
+        /// </remarks>
+        /// <param name="id">Id da manutenção</param>
+        /// <param name="updateDTO">Campos para atualizar manutenção</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Manutenção atualizada</returns>
+        /// <response code="200">Manutenção atualizada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Manutenção não encontrada</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadMaintenanceDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadMaintenanceDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadMaintenanceDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadMaintenanceDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateMaintenanceDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar manutenção 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar manutenção 
+        /// </remarks>
+        /// <param name="id">Id da manutenção</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Manutenção habilitada</returns>
+        /// <response code="200">Manutenção habilitada com sucesso</response>
+        /// <response code="404">Manutenção não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar manutenção
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Manutenção 
+        /// </remarks>
+        /// <param name="id">Id da manutenção</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Manutenção deletada</returns>
+        /// <response code="200">Manutenção deletada com sucesso</response>
+        /// <response code="404">Manutenção não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter manutenções paginadas e filtradas
+        /// </summary>
+        /// <remarks>
+        /// GET de Manutenções
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Manutenções paginadas e filtradas</returns>
+        /// <response code="200">Manutenções paginadas e filtradas com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadMaintenanceDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter manutenção por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id da manutenção
+        /// </remarks>
+        /// <param name="id">Id da manutenção</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Manutenção encontrada</returns>
+        /// <response code="200">Manutenção encontrada com sucesso</response>
+        /// <response code="404">Manutenção não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadMaintenanceDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadMaintenanceDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/StopController.cs b/OneBus.API/Controllers/StopController.cs
index 0b30911..f5395fb 100644
--- a/OneBus.API/Controllers/StopController.cs
+++ b/OneBus.API/Controllers/StopController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.Stop;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.Stop;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Paradas")]
     public class StopController : BaseController<Stop, CreateStopDTO, ReadStopDTO, UpdateStopDTO, BaseFilter>
     {
         public StopController(
@@ -12,5 +17,116 @@ public StopController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar nova parada 
+        /// </summary>
+        /// <remarks>
+        /// POST de Parada
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Parada cadastrada</returns>
+        /// <response code="200">Parada cadastrada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadStopDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadStopDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateStopDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar parada 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Parada
+        /// </remarks>
+        /// <param name="id">Id da parada</param>
+        /// <param name="updateDTO">Campos para atualizar parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Parada atualizada</returns>
+        /// <response code="200">Parada atualizada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Parada não encontrada</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadStopDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadStopDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadStopDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadStopDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateStopDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar parada 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar parada 
+        /// </remarks>
+        /// <param name="id">Id da parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Parada habilitada</returns>
+        /// <response code="200">Parada habilitada com sucesso</response>
+        /// <response code="404">Parada não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar parada
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Parada 
+        /// </remarks>
+        /// <param name="id">Id da parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Parada deletada</returns>
+        /// <response code="200">Parada deletada com sucesso</response>
+        /// <response code="404">Parada não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter paradas paginadas e filtradas
+        /// </summary>
+        /// <remarks>
+        /// GET de Paradas
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Paradas paginadas e filtradas</returns>
+        /// <response code="200">Paradas paginadas e filtradas com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadStopDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter parada por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id da parada
+        /// </remarks>
+        /// <param name="id">Id da parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Parada encontrada</returns>
+        /// <response code="200">Parada encontrada com sucesso</response>
+        /// <response code="404">Parada não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadStopDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadStopDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/StopTimeController.cs b/OneBus.API/Controllers/StopTimeController.cs
index efa3cc1..bd06f9b 100644
--- a/OneBus.API/Controllers/StopTimeController.cs
+++ b/OneBus.API/Controllers/StopTimeController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.StopTime;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.StopTime;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Horários da Parada")]
     public class StopTimeController : BaseController<StopTime, CreateStopTimeDTO, ReadStopTimeDTO, UpdateStopTimeDTO, BaseFilter>
     {
         public StopTimeController(
@@ -12,5 +17,116 @@ public StopTimeController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar novo horário de parada 
+        /// </summary>
+        /// <remarks>
+        /// POST de Horário de Parada
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar horário de parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Parada cadastrado</returns>
+        /// <response code="200">Horário de Parada cadastrado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadStopTimeDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadStopTimeDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateStopTimeDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar horário de parada 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Horário de Parada
+        /// </remarks>
+        /// <param name="id">Id do horário de parada</param>
+        /// <param name="updateDTO">Campos para atualizar horário de parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Parada atualizado</returns>
+        /// <response code="200">Horário de Parada atualizado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Horário de Parada não encontrado</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadStopTimeDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadStopTimeDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadStopTimeDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadStopTimeDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateStopTimeDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar horário de parada 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar horário de parada 
+        /// </remarks>
+        /// <param name="id">Id do horário de parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Parada habilitado</returns>
+        /// <response code="200">Horário de Parada habilitado com sucesso</response>
+        /// <response code="404">Horário de Parada não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar horário de parada
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Horário de Parada 
+        /// </remarks>
+        /// <param name="id">Id do horário de parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Parada deletado</returns>
+        /// <response code="200">Horário de Parada deletado com sucesso</response>
+        /// <response code="404">Horário de Parada não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter horários de parada paginados e filtrados
+        /// </summary>
+        /// <remarks>
+        /// GET de Horários de Parada
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horários de Parada paginados e filtrados</returns>
+        /// <response code="200">Horários de Parada paginados e filtrados com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadStopTimeDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter horário de parada por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id do horário de parada
+        /// </remarks>
+        /// <param name="id">Id do horário de parada</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Horário de Parada encontrado</returns>
+        /// <response code="200">Horário de Parada encontrado com sucesso</response>
+        /// <response code="404">Horário de Parada não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadStopTimeDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadStopTimeDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/UserController.cs b/OneBus.API/Controllers/UserController.cs
index db17e83..5022cbf 100644
--- a/OneBus.API/Controllers/UserController.cs
+++ b/OneBus.API/Controllers/UserController.cs
@@ -4,11 +4,15 @@
 using OneBus.Application.DTOs.Login;
 using OneBus.Application.DTOs.User;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Usuários")]
     public class UserController : BaseController<User, CreateUserDTO, ReadUserDTO, UpdateUserDTO, BaseFilter>
     {
         public UserController(
@@ -18,17 +22,131 @@ public UserController(
         }
 
         /// <summary>
-        /// 
+        /// Efetuar login
         /// </summary>
+        /// <remarks>
+        /// POST de Login
+        /// </remarks>
         /// <param name="login"></param>
         /// <param name="cancellationToken"></param>
-        /// <returns></returns>
-        [HttpPost("login")]
-        [AllowAnonymous]
+        /// <returns>Usuário autenticado</returns>
         [EnableRateLimiting("login")]
-        public async Task<IActionResult> LoginAsync([FromBody] LoginDTO login, CancellationToken cancellationToken = default)
+        [AllowAnonymous]
+        [HttpPost("login")]
+        public Task<IActionResult> LoginAsync([FromBody] LoginDTO login, CancellationToken cancellationToken = default)
         {
             throw new NotImplementedException();
         }
+
+        /// <summary>
+        /// Cadastrar novo usuário 
+        /// </summary>
+        /// <remarks>
+        /// POST de Usuário
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar usuário</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Usuário cadastrado</returns>
+        /// <response code="200">Usuário cadastrado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadUserDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadUserDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateUserDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar usuário 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Usuário
+        /// </remarks>
+        /// <param name="id">Id do usuário</param>
+        /// <param name="updateDTO">Campos para atualizar usuário</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Usuário atualizado</returns>
+        /// <response code="200">Usuário atualizado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Usuário não encontrado</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadUserDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadUserDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadUserDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadUserDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateUserDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar usuário 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar usuário 
+        /// </remarks>
+        /// <param name="id">Id do usuário</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Usuário habilitado</returns>
+        /// <response code="200">Usuário habilitado com sucesso</response>
+        /// <response code="404">Usuário não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar usuário 
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Usuário 
+        /// </remarks>
+        /// <param name="id">Id do usuário</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Usuário deletado</returns>
+        /// <response code="200">Usuário deletado com sucesso</response>
+        /// <response code="404">Usuário não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter usuários paginados e filtrados
+        /// </summary>
+        /// <remarks>
+        /// GET de Usuários
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Usuários paginados e filtrados</returns>
+        /// <response code="200">Usuários paginados e filtrados com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadUserDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter usuário por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id de usuário
+        /// </remarks>
+        /// <param name="id">Id do usuário</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Usuário encontrado</returns>
+        /// <response code="200">Usuário encontrado com sucesso</response>
+        /// <response code="404">Usuário não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadUserDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadUserDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/VehicleController.cs b/OneBus.API/Controllers/VehicleController.cs
index f81ab5c..a561f49 100644
--- a/OneBus.API/Controllers/VehicleController.cs
+++ b/OneBus.API/Controllers/VehicleController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.Vehicle;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.Vehicle;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Veículos")]
     public class VehicleController : BaseController<Vehicle, CreateVehicleDTO, ReadVehicleDTO, UpdateVehicleDTO, BaseFilter>
     {
         public VehicleController(
@@ -12,5 +17,116 @@ public VehicleController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar novo veículo 
+        /// </summary>
+        /// <remarks>
+        /// POST de Veículo
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Veículo cadastrado</returns>
+        /// <response code="200">Veículo cadastrado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadVehicleDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadVehicleDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateVehicleDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar veículo 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Veículo
+        /// </remarks>
+        /// <param name="id">Id do veículo</param>
+        /// <param name="updateDTO">Campos para atualizar veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Veículo atualizado</returns>
+        /// <response code="200">Veículo atualizado com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Veículo não encontrado</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadVehicleDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadVehicleDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadVehicleDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadVehicleDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateVehicleDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar veículo 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar veículo 
+        /// </remarks>
+        /// <param name="id">Id do veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Veículo habilitado</returns>
+        /// <response code="200">Veículo habilitado com sucesso</response>
+        /// <response code="404">Veículo não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar veículo 
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Veículo 
+        /// </remarks>
+        /// <param name="id">Id do veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Veículo deletado</returns>
+        /// <response code="200">Veículo deletado com sucesso</response>
+        /// <response code="404">Veículo não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter veículos paginados e filtrados
+        /// </summary>
+        /// <remarks>
+        /// GET de Veículos
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Veículos paginados e filtrados</returns>
+        /// <response code="200">Veículos paginados e filtrados com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadVehicleDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter veículo por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id de veículo
+        /// </remarks>
+        /// <param name="id">Id do veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Veículo encontrado</returns>
+        /// <response code="200">Veículo encontrado com sucesso</response>
+        /// <response code="404">Veículo não encontrado</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadVehicleDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadVehicleDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/VehicleGarageController.cs b/OneBus.API/Controllers/VehicleGarageController.cs
index 2c6a6b8..363504e 100644
--- a/OneBus.API/Controllers/VehicleGarageController.cs
+++ b/OneBus.API/Controllers/VehicleGarageController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.VehicleGarage;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.VehicleGarage;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Garagem de Veículos")]
     public class VehicleGarageController : BaseController<VehicleGarage, CreateVehicleGarageDTO, ReadVehicleGarageDTO, UpdateVehicleGarageDTO, BaseFilter>
     {
         public VehicleGarageController(
@@ -12,5 +17,116 @@ public VehicleGarageController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar nova garagem de veículo 
+        /// </summary>
+        /// <remarks>
+        /// POST de Garagem de Veículo
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar garagem de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Garagem de Veículo cadastrada</returns>
+        /// <response code="200">Garagem de Veículo cadastrada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadVehicleGarageDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadVehicleGarageDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateVehicleGarageDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar garagem de veículo 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Garagem de Veículo
+        /// </remarks>
+        /// <param name="id">Id da garagem de veículo</param>
+        /// <param name="updateDTO">Campos para atualizar garagem de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Garagem de Veículo atualizada</returns>
+        /// <response code="200">Garagem de Veículo atualizada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Garagem de Veículo não encontrada</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadVehicleGarageDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadVehicleGarageDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadVehicleGarageDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadVehicleGarageDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateVehicleGarageDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar garagem de veículo 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar garagem de veículo
+        /// </remarks>
+        /// <param name="id">Id da garagem de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Garagem de Veículo habilitada</returns>
+        /// <response code="200">Garagem de Veículo habilitada com sucesso</response>
+        /// <response code="404">Garagem de Veículo não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar garagem de veículo 
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Garagem de Veículo
+        /// </remarks>
+        /// <param name="id">Id da garagem de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Garagem de Veículo deletada</returns>
+        /// <response code="200">Garagem de Veículo deletada com sucesso</response>
+        /// <response code="404">Garagem de Veículo não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter garagem de veículos paginadas e filtradas
+        /// </summary>
+        /// <remarks>
+        /// GET de Garagem de Veículos
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Garagem de Veículos paginadas e filtradas</returns>
+        /// <response code="200">Garagem de Veículos paginadas e filtradas com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadVehicleGarageDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter garagem de veículo por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id da garagem de veículo
+        /// </remarks>
+        /// <param name="id">Id da garagem de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Garagem de Veículo encontrada</returns>
+        /// <response code="200">Garagem de Veículo encontrada com sucesso</response>
+        /// <response code="404">Garagem de Veículo não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadVehicleGarageDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadVehicleGarageDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }
diff --git a/OneBus.API/Controllers/VehicleOperationController.cs b/OneBus.API/Controllers/VehicleOperationController.cs
index d492a54..8bab7c5 100644
--- a/OneBus.API/Controllers/VehicleOperationController.cs
+++ b/OneBus.API/Controllers/VehicleOperationController.cs
@@ -1,10 +1,15 @@
-using OneBus.Application.DTOs.VehicleOperation;
+using Microsoft.AspNetCore.Mvc;
+using OneBus.Application.DTOs.VehicleOperation;
 using OneBus.Application.Interfaces.Services;
+using OneBus.Domain.Commons;
+using OneBus.Domain.Commons.Result;
 using OneBus.Domain.Entities;
 using OneBus.Domain.Filters;
+using Swashbuckle.AspNetCore.Annotations;
 
 namespace OneBus.API.Controllers
 {
+    [SwaggerTag("Controlador responsável por gerenciar Operações de Veículos")]
     public class VehicleOperationController : BaseController<VehicleOperation, CreateVehicleOperationDTO, ReadVehicleOperationDTO, UpdateVehicleOperationDTO, BaseFilter>
     {
         public VehicleOperationController(
@@ -12,5 +17,116 @@ public VehicleOperationController(
             : base(baseService)
         {
         }
+
+        /// <summary>
+        /// Cadastrar nova operação de veículo 
+        /// </summary>
+        /// <remarks>
+        /// POST de Operação de Veículo
+        /// </remarks>
+        /// <param name="createDTO">Campos para cadastrar operação de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Operação de Veículo cadastrada</returns>
+        /// <response code="200">Operação de Veículo cadastrada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadVehicleOperationDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadVehicleOperationDTO>), StatusCodes.Status422UnprocessableEntity)]
+        public override Task<IActionResult> CreateAsync([FromBody] CreateVehicleOperationDTO createDTO, CancellationToken cancellationToken = default)
+        {
+            return base.CreateAsync(createDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Atualizar operação de veículo 
+        /// </summary>
+        /// <remarks>
+        /// PUT de Operação de Veículo
+        /// </remarks>
+        /// <param name="id">Id da operação de veículo</param>
+        /// <param name="updateDTO">Campos para atualizar operação de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Operação de Veículo atualizada</returns>
+        /// <response code="200">Operação de Veículo atualizada com sucesso</response>
+        /// <response code="422">Validação encontrou erros</response>
+        /// <response code="404">Operação de Veículo não encontrada</response>
+        /// <response code="409">Conflito entre ids</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadVehicleOperationDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(InvalidResult<ReadVehicleOperationDTO>), StatusCodes.Status422UnprocessableEntity)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadVehicleOperationDTO>), StatusCodes.Status404NotFound)]
+        [ProducesResponseType(typeof(ConflictResult<ReadVehicleOperationDTO>), StatusCodes.Status409Conflict)]
+        public override Task<IActionResult> UpdateAsync([FromRoute] ulong id, [FromBody] UpdateVehicleOperationDTO updateDTO, CancellationToken cancellationToken = default)
+        {
+            return base.UpdateAsync(id, updateDTO, cancellationToken);
+        }
+
+        /// <summary>
+        /// Habilitar operação de veículo 
+        /// </summary>
+        /// <remarks>
+        /// PUT para habilitar operação de veículo 
+        /// </remarks>
+        /// <param name="id">Id da operação de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Operação de Veículo habilitada</returns>
+        /// <response code="200">Operação de Veículo habilitada com sucesso</response>
+        /// <response code="404">Operação de Veículo não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> EnableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.EnableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Desabilitar operação de veículo 
+        /// </summary>
+        /// <remarks>
+        /// DELETE de Operação de Veículo 
+        /// </remarks>
+        /// <param name="id">Id da operação de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Operação de Veículo deletada</returns>
+        /// <response code="200">Operação de Veículo deletada com sucesso</response>
+        /// <response code="404">Operação de Veículo não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<bool>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<bool>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> DisableAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.DisableAsync(id, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter operações de veículos paginadas e filtradas
+        /// </summary>
+        /// <remarks>
+        /// GET de Operações de Veículos
+        /// </remarks>
+        /// <param name="filter">Filtros para aplicar</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Operações de Veículos paginadas e filtradas</returns>
+        /// <response code="200">Operações de Veículos paginadas e filtradas com sucesso</response>
+        [ProducesResponseType(typeof(SuccessResult<Pagination<ReadVehicleOperationDTO>>), StatusCodes.Status200OK)]
+        public override Task<IActionResult> GetPaginedAsync([FromQuery] BaseFilter filter, CancellationToken cancellationToken = default)
+        {
+            return base.GetPaginedAsync(filter, cancellationToken);
+        }
+
+        /// <summary>
+        /// Obter operação de veículo por id
+        /// </summary>
+        /// <remarks>
+        /// GET pelo id da operação de veículo
+        /// </remarks>
+        /// <param name="id">Id da operação de veículo</param>
+        /// <param name="cancellationToken"></param>
+        /// <returns>Operação de Veículo encontrada</returns>
+        /// <response code="200">Operação de Veículo encontrada com sucesso</response>
+        /// <response code="404">Operação de Veículo não encontrada</response>
+        [ProducesResponseType(typeof(SuccessResult<ReadVehicleOperationDTO>), StatusCodes.Status200OK)]
+        [ProducesResponseType(typeof(NotFoundResult<ReadVehicleOperationDTO>), StatusCodes.Status404NotFound)]
+        public override Task<IActionResult> GetByIdAsync([FromRoute] ulong id, CancellationToken cancellationToken = default)
+        {
+            return base.GetByIdAsync(id, cancellationToken);
+        }
     }
 }