import { ServerRoute } from "@hapi/hapi";
import { SeaQAHandler } from "../handlers/seaQA.handler";
import {
    seaQAQuestionRequest, seaQAQuestionResponse, seaQAQuestionListRequest,
    seaQAQuestionListResponse, seaQAQuestionAdminActionRequest,
    seaQAAnswerRequest, seaQAAnswerResponse, seaQACommentRequest,
    seaQACommentResponse, seaQACommentListResponse, seaQALikeResponse,
    seaQAFollowedTopicsResponse, categoryApplicabilityRequest,
    seaQAIdParam, seaQAQuestionIdParam, seaQAAnswerIdParam,
    seaQACategoryIdParam, seaQALikeParams, seaQAAnswerFeaturedRequest,
    seaQAAnswerListRequest, seaQAAnswerListResponse, seaQAQuestionSimpleListResponse,
    seaQAAnswerUpdateRequest,
    seaQAAnswerAdminActionRequest, seaQAQuestionGoodRequest, seaQAQuestionPublicCodeParam,
    seaQAQuestionUpdateRequest, seaQAQuestionRequestAnswerRequest, seaQAQuestionRequestAnswerResponse,
    seaQAQuestionDetailWithAnswersResponse, seaQACommentListRequest,
    seaQACommentGlobalListRequest, seaQACommentGlobalListResponse,
    seaQABookmarkParams, seaQABookmarkListRequest, seaQABookmarkResponse
} from "../validators/seaQA.validator";
import {
    options, error400, error401, error403, error404, error500, confirmationOnly
} from "../validators/global.validator.schema";
import { Common } from "../../utils/common";
import { I18N } from "../../utils/i18n";

const seaQAHandler = new SeaQAHandler();

const seaQARoutes: ServerRoute[] = [
    // --- Questions ---
    {
        method: 'POST',
        path: '/sea-qa/question',
        handler: seaQAHandler.askQuestion,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('CREATE_SEA_QA_QUESTION_DESCRIPTION'),
            notes: I18N.t('CREATE_SEA_QA_QUESTION_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                payload: seaQAQuestionRequest
            },
            response: {
                status: {
                    200: seaQAQuestionDetailWithAnswersResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 1 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/question/{id}',
        handler: seaQAHandler.getQuestionDetail,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('GET_SEA_QA_QUESTION_BY_ID_DESCRIPTION'),
            notes: I18N.t('GET_SEA_QA_QUESTION_BY_ID_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAIdParam
            },
            response: {
                status: {
                    200: seaQAQuestionDetailWithAnswersResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 2 } }
        }
    },
    {
        method: 'PATCH',
        path: '/sea-qa/question/{id}',
        handler: seaQAHandler.updateQuestion,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('UPDATE_SEA_QA_QUESTION_DESCRIPTION'),
            notes: I18N.t('UPDATE_SEA_QA_QUESTION_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAIdParam,
                payload: seaQAQuestionUpdateRequest
            },
            response: {
                status: {
                    200: seaQAQuestionResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 3 } }
        }
    },
    {
        method: 'DELETE',
        path: '/sea-qa/question/{id}',
        handler: seaQAHandler.deleteQuestion,
        options: {
            tags: ['api', 'SeaQA'],
            description: 'Delete a draft/pending question',
            notes: 'Allows the author to delete their question if it is still pending.',
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAIdParam
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 3 } }
        }
    },
    {
        method: 'POST',
        path: '/sea-qa/question/{id}/request-answer',
        handler: seaQAHandler.requestAnswer,
        options: {
            tags: ['api', 'SeaQA', 'Admin'],
            description: I18N.t('REQUEST_ANSWER_SEA_QA_QUESTION_DESCRIPTION'),
            notes: I18N.t('REQUEST_ANSWER_SEA_QA_QUESTION_NOTE'),
            auth: { strategies: ['jwt'], scope: ['admin'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAIdParam,
                payload: seaQAQuestionRequestAnswerRequest
            },
            response: {
                status: {
                    200: seaQAQuestionRequestAnswerResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 4 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/question/list',
        handler: seaQAHandler.listQuestions,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('LIST_SEA_QA_QUESTION_DESCRIPTION'),
            notes: I18N.t('LIST_SEA_QA_QUESTION_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                query: seaQAQuestionListRequest
            },
            response: {
                status: {
                    200: seaQAQuestionListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 3 } }
        }
    },
    {
        method: 'POST',
        path: '/sea-qa/admin/question/action',
        handler: seaQAHandler.adminQuestionAction,
        options: {
            tags: ['api', 'SeaQA', 'Admin'],
            description: I18N.t('ADMIN_SEA_QA_QUESTION_ACTION_DESCRIPTION'),
            notes: I18N.t('ADMIN_SEA_QA_QUESTION_ACTION_NOTE'),
            auth: { strategies: ['jwt'], scope: ['admin'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                payload: seaQAQuestionAdminActionRequest
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 4 } }
        }
    },
    {
        method: 'POST',
        path: '/sea-qa/admin/question/{id}/good',
        handler: seaQAHandler.markAsGoodQuestion,
        options: {
            tags: ['api', 'SeaQA', 'Admin'],
            description: I18N.t('MARK_GOOD_SEA_QA_QUESTION_DESCRIPTION'),
            notes: I18N.t('MARK_GOOD_SEA_QA_QUESTION_NOTE'),
            auth: { strategies: ['jwt'], scope: ['admin'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAIdParam,
                payload: seaQAQuestionGoodRequest
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 5 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/question/all',
        handler: seaQAHandler.listQuestionsAll,
        options: {
            tags: ['api', 'SeaQA'],
            description: 'Get all questions with limited response fields',
            notes: 'Returns a list of all questions containing only id, title, code, and status.',
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                query: seaQAQuestionListRequest
            },
            response: {
                status: {
                    200: seaQAQuestionSimpleListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 6 } }
        }
    },

    // --- Answers ---
    {
        method: 'POST',
        path: '/sea-qa/question/{questionId}/answer',
        handler: seaQAHandler.postAnswer,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('POST_SEA_QA_ANSWER_DESCRIPTION'),
            notes: I18N.t('POST_SEA_QA_ANSWER_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAQuestionIdParam,
                payload: seaQAAnswerRequest
            },
            response: {
                status: {
                    200: seaQAAnswerResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 6 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/answer/list',
        handler: seaQAHandler.listAnswers,
        options: {
            tags: ['api', 'SeaQA'],
            description: 'List sea QA answers with filters',
            notes: 'Retrieve sea QA answers matching filters like questionId, status, and isFeatured.',
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                query: seaQAAnswerListRequest
            },
            response: {
                status: {
                    200: seaQAAnswerListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 7 } }
        }
    },
    {
        method: 'PATCH',
        path: '/sea-qa/answer/{id}',
        handler: seaQAHandler.updateAnswer,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('UPDATE_SEA_QA_ANSWER_DESCRIPTION'),
            notes: I18N.t('UPDATE_SEA_QA_ANSWER_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAIdParam,
                payload: seaQAAnswerUpdateRequest
            },
            response: {
                status: {
                    200: seaQAAnswerResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 7 } }
        }
    },
    {
        method: 'DELETE',
        path: '/sea-qa/answer/{id}',
        handler: seaQAHandler.deleteAnswer,
        options: {
            tags: ['api', 'SeaQA'],
            description: 'Delete a draft answer',
            notes: 'Allows the author to delete their answer if it is a draft or pending approval.',
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAIdParam
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 7 } }
        }
    },
    {
        method: 'PUT',
        path: '/sea-qa/answer/{id}',
        handler: seaQAHandler.updateAnswer,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('UPDATE_SEA_QA_ANSWER_DESCRIPTION'),
            notes: I18N.t('UPDATE_SEA_QA_ANSWER_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAIdParam,
                payload: seaQAAnswerUpdateRequest
            },
            response: {
                status: {
                    200: seaQAAnswerResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 7 } }
        }
    },
    {
        method: 'POST',
        path: '/sea-qa/admin/answer/action',
        handler: seaQAHandler.adminAnswerAction,
        options: {
            tags: ['api', 'SeaQA', 'Admin'],
            description: I18N.t('ADMIN_SEA_QA_ANSWER_ACTION_DESCRIPTION'),
            notes: I18N.t('ADMIN_SEA_QA_ANSWER_ACTION_NOTE'),
            auth: { strategies: ['jwt'], scope: ['admin'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                payload: seaQAAnswerAdminActionRequest
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 8 } }
        }
    },
    {
        method: 'POST',
        path: '/sea-qa/admin/answer/{id}/featured',
        handler: seaQAHandler.markAsFeaturedAnswer,
        options: {
            tags: ['api', 'SeaQA', 'Admin'],
            description: I18N.t('MARK_FEATURED_SEA_QA_ANSWER_DESCRIPTION'),
            notes: I18N.t('MARK_FEATURED_SEA_QA_ANSWER_NOTE'),
            auth: { strategies: ['jwt'], scope: ['admin'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAIdParam,
                payload: seaQAAnswerFeaturedRequest
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 9 } }
        }
    },

    // --- Comments ---
    {
        method: 'POST',
        path: '/sea-qa/answer/{answerId}/comment',
        handler: seaQAHandler.postComment,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('POST_SEA_QA_COMMENT_DESCRIPTION'),
            notes: I18N.t('POST_SEA_QA_COMMENT_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAAnswerIdParam,
                payload: seaQACommentRequest
            },
            response: {
                status: {
                    200: seaQACommentResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 10 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/answer/{answerId}/comments',
        handler: seaQAHandler.getComments,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('GET_SEA_QA_COMMENTS_DESCRIPTION'),
            notes: I18N.t('GET_SEA_QA_COMMENTS_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAAnswerIdParam,
                query: seaQACommentListRequest
            },
            response: {
                status: {
                    200: seaQACommentListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 11 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/comment/list',
        handler: seaQAHandler.listComments,
        options: {
            tags: ['api', 'SeaQA'],
            description: 'List sea QA comments globally with filters',
            notes: 'Retrieve all sea QA comments globally matching filters like userId or answerId.',
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                query: seaQACommentGlobalListRequest
            },
            response: {
                status: {
                    200: seaQACommentGlobalListResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 12 } }
        }
    },

    // --- Bookmarks ---
    {
        method: 'POST',
        path: '/sea-qa/bookmark/{entityType}/{entityId}',
        handler: seaQAHandler.toggleBookmark,
        options: {
            tags: ['api', 'SeaQA'],
            description: 'Toggle bookmark on a Sea QA question or answer',
            notes: 'Toggles the current user bookmark state for the selected question or answer.',
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQABookmarkParams
            },
            response: {
                status: {
                    200: seaQABookmarkResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 12 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/bookmark/list',
        handler: seaQAHandler.listBookmarks,
        options: {
            tags: ['api', 'SeaQA'],
            description: 'List bookmarked questions or answers',
            notes: 'Returns paginated list of bookmarks for the current user.',
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                query: seaQABookmarkListRequest
            },
            plugins: { 'hapi-swagger': { order: 12 } }
        }
    },

    // --- Likes ---
    {
        method: 'POST',
        path: '/sea-qa/like/{entityType}/{entityId}',
        handler: seaQAHandler.toggleLike,
        options: {
            tags: ['api', 'SeaQA'],
            description: 'Toggle like on a Sea QA question or answer',
            notes: 'Toggles the current user like state for the selected question or answer.',
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQALikeParams
            },
            response: {
                status: {
                    200: seaQALikeResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 12 } }
        }
    },

    // --- Topics/Follow ---
    {
        method: 'POST',
        path: '/sea-qa/topic/{categoryId}/follow',
        handler: seaQAHandler.followTopic,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('FOLLOW_SEA_QA_TOPIC_DESCRIPTION'),
            notes: I18N.t('FOLLOW_SEA_QA_TOPIC_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQACategoryIdParam
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 13 } }
        }
    },
    {
        method: 'POST',
        path: '/sea-qa/topic/{categoryId}/unfollow',
        handler: seaQAHandler.unfollowTopic,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('UNFOLLOW_SEA_QA_TOPIC_DESCRIPTION'),
            notes: I18N.t('UNFOLLOW_SEA_QA_TOPIC_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQACategoryIdParam
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 14 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/topics/followed',
        handler: seaQAHandler.getFollowedTopics,
        options: {
            tags: ['api', 'SeaQA'],
            description: I18N.t('GET_FOLLOWED_SEA_QA_TOPICS_DESCRIPTION'),
            notes: I18N.t('GET_FOLLOWED_SEA_QA_TOPICS_NOTE'),
            auth: { strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover
            },
            response: {
                status: {
                    200: seaQAFollowedTopicsResponse,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 15 } }
        }
    },

    // --- Applicability ---
    {
        method: 'POST',
        path: '/sea-qa/admin/topic/{categoryId}/applicability',
        handler: seaQAHandler.updateCategoryApplicability,
        options: {
            tags: ['api', 'SeaQA', 'Admin'],
            description: I18N.t('UPDATE_SEA_QA_TOPIC_APPLICABILITY_DESCRIPTION'),
            notes: I18N.t('UPDATE_SEA_QA_TOPIC_APPLICABILITY_NOTE'),
            auth: { strategies: ['jwt'], scope: ['admin'] },
            validate: {
                headers: Common.routeHeaders("authorized"),
                options: options,
                failAction: Common.failover,
                params: seaQACategoryIdParam,
                payload: categoryApplicabilityRequest
            },
            response: {
                status: {
                    200: confirmationOnly,
                    400: error400,
                    401: error401,
                    403: error403,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 16 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/public/question/list',
        handler: seaQAHandler.listPublicQuestions,
        options: {
            tags: ['api', 'SeaQA', 'Public'],
            description: I18N.t('PUBLIC_LIST_SEA_QA_QUESTIONS_DESCRIPTION'),
            notes: I18N.t('PUBLIC_LIST_SEA_QA_QUESTIONS_NOTE'),
            auth: { mode: 'optional', strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("optionalauthorized"),
                options: options,
                failAction: Common.failover,
                query: seaQAQuestionListRequest
            },
            response: {
                status: {
                    200: seaQAQuestionListResponse,
                    400: error400,
                    401: error401,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 17 } }
        }
    },
    {
        method: 'GET',
        path: '/sea-qa/public/question/{code}',
        handler: seaQAHandler.getPublicQuestionDetail,
        options: {
            tags: ['api', 'SeaQA', 'Public'],
            description: I18N.t('PUBLIC_GET_SEA_QA_QUESTION_DESCRIPTION'),
            notes: I18N.t('PUBLIC_GET_SEA_QA_QUESTION_NOTE'),
            auth: { mode: 'optional', strategies: ['jwt'] },
            validate: {
                headers: Common.routeHeaders("optionalauthorized"),
                options: options,
                failAction: Common.failover,
                params: seaQAQuestionPublicCodeParam
            },
            response: {
                status: {
                    200: seaQAQuestionDetailWithAnswersResponse,
                    400: error400,
                    401: error401,
                    404: error404,
                    500: error500
                }
            },
            plugins: { 'hapi-swagger': { order: 18 } }
        }
    }
];

export default seaQARoutes;