/*-
 * #%L
 * Smile CDR - CDR
 * %%
 * Copyright (C) 2016 - 2025 Smile CDR, Inc.
 * %%
 * All rights reserved.
 * #L%
 */
package ca.cdr.api.fhir.interceptor;

import ca.cdr.api.consent.ConsentActiveResourceResolutionRequest;
import ca.cdr.api.consent.ConsentFetchQueries;
import ca.cdr.api.consent.ConsentFixedPolicyRequest;
import ca.cdr.api.consent.ConsentLookupContext;
import ca.cdr.api.fhirgw.json.AvailableRoutesJson;
import ca.cdr.api.fhirgw.json.GatewayTargetJson;
import ca.cdr.api.fhirgw.json.MatchedRoutesJson;
import ca.cdr.api.fhirgw.model.CreateRequest;
import ca.cdr.api.fhirgw.model.DeleteRequest;
import ca.cdr.api.fhirgw.model.HistoryRequest;
import ca.cdr.api.fhirgw.model.ISearchResultsAccumulator;
import ca.cdr.api.fhirgw.model.OperationRequest;
import ca.cdr.api.fhirgw.model.OperationResponse;
import ca.cdr.api.fhirgw.model.ReadRequest;
import ca.cdr.api.fhirgw.model.SearchPageRequest;
import ca.cdr.api.fhirgw.model.SearchRequest;
import ca.cdr.api.fhirgw.model.SearchResponse;
import ca.cdr.api.fhirgw.model.TransactionRequest;
import ca.cdr.api.fhirgw.model.UpdateRequest;
import ca.cdr.api.model.json.AuditEventJson;
import ca.cdr.api.model.json.AuditEventPrePersistJson;
import ca.cdr.api.model.json.ConvertedTransactionBundlesJson;
import ca.cdr.api.model.json.IOAuth2ClientDetails;
import ca.cdr.api.model.json.OAuth2ClientDetailsJson;
import ca.cdr.api.model.json.OpenIdTokenResponse;
import ca.cdr.api.model.json.UserSessionDetailsJson;
import ca.cdr.api.model.json.appgallery.common.AGApplicationJson;
import ca.cdr.api.model.json.appgallery.console.AGConsoleJson;
import ca.cdr.api.persistence.megascale.MegaScaleCredentialRequestJson;
import ca.cdr.api.persistence.megascale.MegaScaleCredentialResponseJson;
import ca.cdr.api.priorauth.PriorAuthCrdContextJson;
import ca.cdr.api.pub.cdaexchange.model.CdaToFhirConversionResultJson;
import ca.cdr.api.pub.hl7v2.model.Hl7v2ToFhirConversionResultJson;
import ca.uhn.fhir.interceptor.api.IPointcut;
import ca.uhn.fhir.rest.api.server.RequestDetails;
import ca.uhn.fhir.rest.api.server.cdshooks.CdsServiceRequestJson;
import ca.uhn.fhir.rest.server.interceptor.consent.IConsentService;
import ca.uhn.fhir.rest.server.messaging.json.ResourceOperationJsonMessage;
import ca.uhn.fhir.rest.server.servlet.ServletRequestDetails;
import ca.uhn.hl7v2.model.Message;
import jakarta.annotation.Nonnull;
import org.apache.commons.lang3.ArrayUtils;
import org.apache.http.client.methods.HttpRequestBase;
import org.hl7.fhir.instance.model.api.IBaseBundle;
import org.hl7.fhir.instance.model.api.IBaseOperationOutcome;
import org.hl7.fhir.instance.model.api.IBaseResource;

import java.security.KeyStore;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.stream.Collectors;

/**
 * Value for {@link CdrHook#value()}
 * <p>
 * Hook pointcuts are divided into several broad categories:
 * <ul>
 * <li>FHIRGW_xxx: Hooks on the FHIR Gateway module</li>
 * </ul>
 * </p>
 */
public enum CdrPointcut implements IPointcut {

        /**
         * <b>CDA pre-import Hook:</b>
         * <p>This pointcut provides access to documents before they are imported via the $import-cda endpoint.</p>
         * <p>Hooks may accept the following parameters:</p>
         * <ul>
         *    <li>{@link java.lang.String} - the document to be imported, in xml format.</li>
         *    <li>{@link ca.cdr.api.pub.cdaexchange.model.CdaToFhirConversionResultJson} - object used to contain all
         *    relevant data involved in the conversion of a CDA document to an IBaseBundle.</li>
         * </ul>
         * <p>Hooks should return the document after performing any modifications.</p>
         */
        CDA_PRE_IMPORT(String.class, String.class, CdaToFhirConversionResultJson.class),

        /**
         * <b>CDA post-import Hook:</b>
         * <p>This pointcut provides access to documents after they are imported via the $import-cda endpoint.</p>
         * <p>Hooks may accept the following parameters:</p>
         * <ul>
         *    <li>{@link IBaseOperationOutcome} - an operation outcome which can be used to track issues with the import.</li>
         *    <li>{@link IBaseBundle} - the transaction bundle which can be modified by this Hook.</li>
         *    <li>{@link java.lang.String} - the document that was imported, in xml format.</li>
         *    <li>{@link ca.cdr.api.pub.cdaexchange.model.CdaToFhirConversionResultJson} - object used to contain all
         *    relevant data involved in the conversion of a CDA document to an IBaseBundle.</li>
         * </ul>
         * <p>To modify the document before the {@link IBaseBundle} is generated, use the pre-import Hook instead.</p>
         */
        CDA_POST_IMPORT(
                        void.class,
                        IBaseOperationOutcome.class,
                        IBaseBundle.class,
                        String.class,
                        CdaToFhirConversionResultJson.class),

        /**
         * <b>CDA post-export Hook:</b>
         * <p>This pointcut provides access to documents after they are exported, and immediately
         * before they are returned to the API client.</p>
         * <p>Hooks may accept the following parameters:</p>
         * <ul>
         *    <li>{@link IBaseBundle} - the bundle associated with this export.</li>
         *    <li>{@link java.lang.String} - the document being exported, in xml format.</li>
         * </ul>
         * <p>Hooks should return the document after performing any modifications. The resulting document
         * is what will be returned to the API client.</p>
         */
        CDA_POST_EXPORT(String.class, IBaseBundle.class, String.class),

        /**
         * <b>Channel Import Hook:</b>
         * The pointcut provides access to messages received on a broker queue.  It allows an interceptor to
         * inspect, modify or mark for discard incoming messages before ingestion by the Channel Import module.
         * <p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ResourceOperationJsonMessage} - Hook methods for this
         * pointcut should take a single parameter of ResourceOperationJsonMessage as the input. This object
         * contains the pre-processed channel import message.
         * </li>
         * </ul>
         *
         * </p>
         * Hook methods must return a <code>Boolean</code> which indicates whether to process the message.
         */
        CHANNEL_IMPORT_MESSAGE_PRE_PROCESSED(Boolean.class, ResourceOperationJsonMessage.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has just determined which routes should be invoked for
         * a given FHIR <b>delete</b> operation. This hook is called once per client request, regardless of how many individual
         * targets are eventually invoked against.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.DeleteRequest} - The delete that is about to be invoked. The hook method can modify this request, and modifications will affect all the operations that are performed against the target servers
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.MatchedRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which have been selected for this request. Routes can be added or removed from this collection to affect which routes are invoked. They can be cast to their specific subclasses if necessary.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.AvailableRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which match the operation type of the request, e.g. read, create, delete, search, operation.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         *
         */
        FHIRGW_DELETE_POST_SELECT_ROUTE(
                        void.class,
                        ServletRequestDetails.class,
                        DeleteRequest.class,
                        MatchedRoutesJson.class,
                        AvailableRoutesJson.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has just determined which routes should be invoked for
         * a given FHIR <b>update</b> operation. This hook is called once per client request, regardless of how many individual
         * targets are eventually invoked against.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.UpdateRequest} - The update that is about to be invoked. The hook method can modify this request, and modifications will affect all the operations that are performed against the target servers
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.MatchedRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which have been selected for this request. Routes can be added or removed from this collection to affect which routes are invoked. They can be cast to their specific subclasses if necessary.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.AvailableRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which match the operation type of the request, e.g. read, create, delete, search, operation.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         *
         */
        FHIRGW_UPDATE_POST_SELECT_ROUTE(
                        void.class,
                        ServletRequestDetails.class,
                        UpdateRequest.class,
                        MatchedRoutesJson.class,
                        AvailableRoutesJson.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has just determined which routes should be invoked for
         * a given FHIR <b>operation</b> operation. This hook is called once per client request, regardless of how many individual
         * targets are eventually invoked against.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.OperationRequest} - The operation that is about to be invoked. The hook method can modify this request, and modifications will affect all the operations that are performed against the target servers
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.MatchedRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which have been selected for this request. Routes can be added or removed from this collection to affect which routes are invoked. They can be cast to their specific subclasses if necessary.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.AvailableRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which match the operation type of the request, e.g. read, create, delete, search, operation.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         *
         */
        FHIRGW_OPERATION_POST_SELECT_ROUTE(
                        void.class,
                        ServletRequestDetails.class,
                        OperationRequest.class,
                        MatchedRoutesJson.class,
                        AvailableRoutesJson.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has just determined which routes should be invoked for
         * a given FHIR <b>search</b> operation. This hook is called once per client request, regardless of how many individual
         * targets are eventually invoked against.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.SearchRequest} - The search that is about to be invoked. The hook method can modify this request, and modifications will affect all the operations that are performed against the target servers
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.MatchedRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which have been selected for this request. Routes can be added or removed from this collection to affect which routes are invoked. They can be cast to their specific subclasses if necessary.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.AvailableRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which match the operation type of the request, e.g. read, create, delete, search, operation.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         *
         */
        FHIRGW_SEARCH_POST_SELECT_ROUTE(
                        void.class,
                        ServletRequestDetails.class,
                        SearchRequest.class,
                        MatchedRoutesJson.class,
                        AvailableRoutesJson.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has just determined which routes should be invoked for
         * a given FHIR <b>create</b> operation. This hook is called once per client request, regardless of how many individual
         * targets are eventually invoked against.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.CreateRequest} - The create that is about to be invoked. The hook method can modify this request, and modifications will affect all the operations that are performed against the target servers
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.MatchedRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which have been selected for this request. Routes can be added or removed from this collection to affect which routes are invoked. They can be cast to their specific subclasses if necessary.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.AvailableRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which match the operation type of the request, e.g. read, create, delete, search, operation.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         *
         */
        FHIRGW_CREATE_POST_SELECT_ROUTE(
                        void.class,
                        ServletRequestDetails.class,
                        CreateRequest.class,
                        MatchedRoutesJson.class,
                        AvailableRoutesJson.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has just determined which routes should be invoked for
         * a given FHIR <b>read</b> operation. This hook is called once per client request, regardless of how many individual
         * targets are eventually invoked against.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.ReadRequest} - The read that is about to be invoked. The hook method can modify this request, and modifications will affect all the operations that are performed against the target servers
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.MatchedRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which have been selected for this request. Routes can be added or removed from this collection to affect which routes are invoked. They can be cast to their specific subclasses if necessary.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.AvailableRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which match the operation type of the request, e.g. read, create, delete, search, operation.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         *
         */
        FHIRGW_READ_POST_SELECT_ROUTE(
                        void.class,
                        ServletRequestDetails.class,
                        ReadRequest.class,
                        MatchedRoutesJson.class,
                        AvailableRoutesJson.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has just determined which routes should be invoked for
         * a given FHIR <b>transaction</b> operation. This hook is called once per client request, regardless of how many individual
         * targets are eventually invoked against.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.TransactionRequest} - The transaction that is about to be invoked. The hook method can modify this request, and modifications will affect all the operations that are performed against the target servers.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.MatchedRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which have been selected for this request. Routes can be added or removed from this collection to affect which routes are invoked. They can be cast to their specific subclasses if necessary.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.AvailableRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which match the operation type of the request, e.g. read, create, delete, search, operation.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         *
         */
        FHIRGW_TRANSACTION_POST_SELECT_ROUTE(
                        void.class,
                        ServletRequestDetails.class,
                        TransactionRequest.class,
                        MatchedRoutesJson.class,
                        AvailableRoutesJson.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway is about to invoke a FHIR <b>read</b> or <b>vread</b> operation against an individual
         * target server. This hook is called once for each target that will be called, so if a single client read is being
         * multicasted against two target servers, this hook will be invoked twice.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.ReadRequest} - The read that is about to be invoked. The hook method can modify this request, and modifications will affect the operation that is actually performed against the target server.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_READ_TARGET_PREINVOKE(void.class, ReadRequest.class, GatewayTargetJson.class, ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway is about to invoke a FHIR <b>instance history</b> operation against an individual
         * target server. This hook is called once for each target that will be called, so if a single client instance history is being
         * multicast against two target servers, this hook will be invoked twice.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.HistoryRequest} - The instance history that is about to be invoked. The hook method can modify this request, and modifications will affect the operation that is actually performed against the target server.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_INSTANCE_HISTORY_TARGET_PREINVOKE(
                        void.class, HistoryRequest.class, GatewayTargetJson.class, ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has just determined which routes should be invoked for
         * a given FHIR <b>instance history</b> operation. This hook is called once per client request, regardless of how many individual
         * targets are eventually invoked.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.HistoryRequest} - The transaction that is about to be invoked. The hook method can modify this request, and modifications will affect all the operations that are performed against the target servers.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.MatchedRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which have been selected for this request. Routes can be added or removed from this collection to affect which routes are invoked. They can be cast to their specific subclasses if necessary.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.AvailableRoutesJson} - A collection of {@link ca.cdr.api.fhirgw.json.IBaseRouteJson} which match the operation type of the request, e.g. read, create, delete, search, operation.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         *
         */
        FHIRGW_INSTANCE_HISTORY_POST_SELECT_ROUTE(
                        void.class,
                        ServletRequestDetails.class,
                        HistoryRequest.class,
                        MatchedRoutesJson.class,
                        AvailableRoutesJson.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway is about to invoke a FHIR <b>operation</b> operation against an individual
         * target server.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.OperationRequest} - The read that is about to be invoked. The hook method can modify this request, and modifications will affect the operation that is actually performed against the target server.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_OPERATION_TARGET_PREINVOKE(
                        void.class, OperationRequest.class, GatewayTargetJson.class, ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has finished invoking a FHIR <b>extended operation</b> operation against an individual
         * target server. This hook is called once for each target that has been called, so if a single client operation is being
         * multicasted against two target servers, this hook will be invoked twice.
         * <p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ISearchResultsAccumulator} - The accumulator being used to collect the search results so far. This may be empty in the case of operations
         * which do not return search results. Some operations, such as <b>$everything</b>, will return search results, but others such as <b>$</b>
         * Hook methods may use this object to inspect results received by other endpoints when searching in serial mode, and can
         * modify the results as needed. Note that the {@link #FHIRGW_SEARCH_TARGET_POSTINVOKE} pointcut is invoked once for each gateway
         * target, <b>before</b> the search results are added to the accumulator. Results from the current target are found in the
         * {@link SearchResponse} object, and will be moved from that object into the accumulator after this pointcut is complete.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.OperationResponse} - This object contains the Operation Response from the individual Gateway Target that was called. Interceptors may modify this object in any way they want. This may be null if the operation returns a Bundle (check the SearchResultsAccumulator instead).
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         *
         **/
        FHIRGW_OPERATION_TARGET_POSTINVOKE(
                        void.class,
                        OperationRequest.class,
                        ISearchResultsAccumulator.class,
                        OperationResponse.class,
                        GatewayTargetJson.class,
                        ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway is about to invoke a FHIR <b>search</b> operation against an individual
         * target server. This hook is called once for each target that will be called, so if a single client search is being
         * multicasted against two target servers, this hook will be invoked twice.
         * <p>
         * This hook can be contrasted with {@link #FHIRGW_SEARCH_PAGE_TARGET_PREINVOKE}:
         * <ul>
         *    <li>{@link #FHIRGW_SEARCH_TARGET_PREINVOKE} is called before the initial search is performed (which should return search results as well as paging links)</li>
         *    <li>{@link #FHIRGW_SEARCH_PAGE_TARGET_PREINVOKE} is called before the subsequent pages of results are fetched</li>
         * </ul>
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.SearchRequest} - The search that is about to be invoked. The hook method can modify this request, and modifications will affect the operation that is actually performed against the target server.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ISearchResultsAccumulator} - The accumulator being used to collect the search results so far. Hook methods may use this object to inspect results recieved by other endpoints when searching in serial mode, and can modify the results as needed.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_SEARCH_TARGET_PREINVOKE(
                        void.class,
                        SearchRequest.class,
                        GatewayTargetJson.class,
                        ISearchResultsAccumulator.class,
                        ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway is about to invoke a FHIR <b>search</b> paging operation against an individual
         * target server. This hook is called once for each target that will be called, so if a single client search is being
         * multicasted against two target servers, this hook will be invoked twice.
         * <p>
         * This hook can be contrasted with {@link #FHIRGW_SEARCH_TARGET_PREINVOKE}:
         * <ul>
         *    <li>{@link #FHIRGW_SEARCH_TARGET_PREINVOKE} is called before the initial search is performed (which should return search results as well as paging links)</li>
         *    <li>{@link #FHIRGW_SEARCH_PAGE_TARGET_PREINVOKE} is called before the subsequent pages of results are fetched</li>
         * </ul>
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.SearchPageRequest} - The search that is about to be invoked. The hook method can modify this request, and modifications will affect the operation that is actually performed against the target server.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ISearchResultsAccumulator} - The accumulator being used to collect the search results so far. Hook methods may use this object to inspect results received by other endpoints when searching in serial mode, and can modify the results as needed.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_SEARCH_PAGE_TARGET_PREINVOKE(
                        void.class,
                        SearchPageRequest.class,
                        GatewayTargetJson.class,
                        ISearchResultsAccumulator.class,
                        ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway has finished invoking a FHIR <b>search</b> operation against an individual
         * target server. This hook is called once for each target that has been called, so if a single client search is being
         * multicasted against two target servers, this hook will be invoked twice.
         * <p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ISearchResultsAccumulator} - The accumulator being used to collect the search results so far.
         * Hook methods may use this object to inspect results received by other endpoints when searching in serial mode, and can
         * modify the results as needed. Note that the {@link #FHIRGW_SEARCH_TARGET_POSTINVOKE} pointcut is invoked once for each gateway
         * target, <b>before</b> the search results are added to the accumulator. Results from the current target are found in the
         * {@link SearchResponse} object, and will be moved from that object into the accumulator after this pointcut is complete.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.SearchResponse} - This object contains the search results from the individual Gateway Target that was called. Interceptors may modify this object in any way they want.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_SEARCH_TARGET_POSTINVOKE(
                        void.class,
                        GatewayTargetJson.class,
                        ISearchResultsAccumulator.class,
                        SearchResponse.class,
                        ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway is about to invoke a FHIR <b>create</b> operation against an individual
         * target server. This hook is called once for each target that will be called, so if a single client create is being
         * multicasted against two target servers, this hook will be invoked twice.
         * <p>
         * For creates where a client id is specified, the <b>update</b> hook will be fired instead.
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.CreateRequest} - The create that is about to be invoked. The hook method can modify this request, and modifications will affect the operation that is actually performed against the target server.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_CREATE_TARGET_PREINVOKE(
                        void.class, CreateRequest.class, GatewayTargetJson.class, ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway is about to invoke a FHIR <b>transaction</b> operation against an individual
         * target server. This hook is called once for each target that will be called, so if a single client create is being
         * multicasted against two target servers, this hook will be invoked twice.
         * <p>
         * For creates where a client id is specified, the <b>update</b> hook will be fired instead.
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.TransactionRequest} - The transaction that is about to be invoked. The hook method can modify this request, and modifications will affect the operation that is actually performed against the target server.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_TRANSACTION_TARGET_PREINVOKE(
                        void.class, TransactionRequest.class, GatewayTargetJson.class, ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway is about to invoke a FHIR <b>update</b> operation against an individual
         * target server. This hook is called once for each target that will be called, so if a single client update is being
         * multicasted against two target servers, this hook will be invoked twice.
         * <p>
         * This hook will also be called for <b>create</b> operations when a client id is provided.
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.UpdateRequest} - The update that is about to be invoked. The hook method can modify this request, and modifications will affect the operation that is actually performed against the target server.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_UPDATE_TARGET_PREINVOKE(
                        void.class, UpdateRequest.class, GatewayTargetJson.class, ServletRequestDetails.class),

        /**
         * <b>FHIR Gateway Hook:</b>
         * This hook is called when the FHIR Gateway is about to invoke a FHIR <b>delete</b> operation against an individual
         * target server. This hook is called once for each target that will be called, so if a single client delete is being
         * multicasted against two target servers, this hook will be invoked twice.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhirgw.model.DeleteRequest} - The delete that is about to be invoked. The hook method can modify this request, and modifications will affect the operation that is actually performed against the target server.
         * </li>
         * <li>
         * {@link ca.cdr.api.fhirgw.json.GatewayTargetJson} - The gateway target server definition. Hook methods should not modify this object, and any changes will be ignored.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.server.servlet.ServletRequestDetails} - A bean containing details about the request that
         * is about to be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        FHIRGW_DELETE_TARGET_PREINVOKE(
                        void.class, DeleteRequest.class, GatewayTargetJson.class, ServletRequestDetails.class),

        /**
         * <b>HL7v2 Hook:</b>
         * This hook is the first one called when a HL7v2 endpoint processes incoming messages.  It is invoked before
         * the HL7v2 to FHIR mapping takes place for each incoming request. It may be used to provide
         * alternate handling for some requests, screen requests before they are handled, alter the incoming message,etc.
         * <p>
         * Note that any exceptions thrown by this method will not be trapped by HAPI (they will be passed up to the server)
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.uhn.hl7v2.model.Message} - the message that is about to be processed. The hook method can modify this
         * message and modifications will affect the end result of processing the message by this server.
         * <br/>
         * <b>NOTE:</b> This parameter is deprecated. Use {@link Hl7v2ToFhirConversionResultJson#getModifiableMessage()}
         * or {@link Hl7v2ToFhirConversionResultJson#setModifiableMessage(Message)} instead.
         * </li>
         * <li>
         * {@link Hl7v2ToFhirConversionResultJson} - Contains all relevant data involved in the conversion of an HL7 v2.x
         * message to a list of IBaseBundle resources.
         * </li>
         * </ul>
         * </p>
         * Hook methods may return <code>true</code> or <code>void</code> if processing should continue normally.
         * This is generally the right thing to do. If your interceptor is processing the response rather than
         * letting HAPI do it, you must return <code>false</code>. In this case,
         * no further processing will occur.
         */
        HL7V2IN_PRE_HL7V2_TO_FHIR_MAPPING_PROCESSING(
                        Boolean.class, "ca.uhn.hl7v2.model.Message", "ca.cdr.api.pub.hl7v2.model.Hl7v2ToFhirConversionResultJson"),

        /**
         * <b>HL7v2 Hook:</b>
         * This hook is invoked after Smile has transformed an HL7V2 message into a collection of Transaction Bundle operations.
         * <p>
         * Note that any exceptions thrown by this method will not be trapped by HAPI (they will be passed up to the server)
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ConvertedTransactionBundlesJson} - Contains a list of IBaseBundle objects, each of which represents a transaction about to be executed
         * against the FHIR repository. Any modifications to this bundle, or additions to it, will be propagated into the repository.
         * <br/>
         * <b>NOTE:</b> This parameter is deprecated. Use {@link Hl7v2ToFhirConversionResultJson#getBundles()}
         * or {@link Hl7v2ToFhirConversionResultJson#setBundles(List)} instead.
         * </li>
         * <li>
         * {@link ca.uhn.hl7v2.model.Message} - the message that was just processed. Any changes to this message will be ignored,
         * as it has already been processed.
         * <br/>
         * <b>NOTE:</b> This parameter is deprecated. Use {@link Hl7v2ToFhirConversionResultJson#getModifiableMessage()}
         * or {@link Hl7v2ToFhirConversionResultJson#setModifiableMessage(Message)} instead.
         * </li>
         * <li>
         * {@link Hl7v2ToFhirConversionResultJson} - Contains all relevant data involved in the conversion of an HL7 v2.x
         * message to a list of IBaseBundle resources.
         * </li>
         * </ul>
         * </p>
         */
        HL7V2IN_POST_HL7V2_TO_FHIR_MAPPING_PROCESSING(
                        void.class,
                        "ca.uhn.hl7v2.model.Message",
                        "ca.cdr.api.model.json.ConvertedTransactionBundlesJson",
                        "ca.cdr.api.pub.hl7v2.model.Hl7v2ToFhirConversionResultJson"),

        /**
         * <b>Persistence (RDBMS) Hook:</b>
         * This pointcut is invoked once by the Persistence (RDBMS) module when
         * the module is starting up.
         *
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * No parameters.
         * </li>
         * </ul>
         * </p>
         * Hook methods should not return a value.
         *
         * @since 2025.05.R01
         */
        STORAGE_STARTING_PRE_START(void.class),

        /**
         * <b>Persistence (RDBMS) Hook:</b>
         * This pointcut is invoked my the Persistence (RDBMS) module when
         * running in MegaScale mode in order to request the database credentials
         * associated with a given partition ID.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link MegaScaleCredentialRequestJson} - Hook methods for this
         * pointcut should take a {@link MegaScaleCredentialRequestJson}
         * as input. This object contains the numeric ID of the partition
         * for which database credentials are wanted.
         * </li>
         * </ul>
         * </p>
         *
         * Hook methods for this pointcut must return a
         * {@link MegaScaleCredentialResponseJson} object which contains the
         * JDBC URL and credentials associated with the partition ID. These
         * credentials will be cached, so this Pointcut will not be invoked
         * repeatedly for the same partition ID (therefore it is ok if hook
         * methods have some latency).
         *
         * @since 2023.02.R01
         */
        STORAGE_MEGASCALE_PROVIDE_DB_INFO(MegaScaleCredentialResponseJson.class, MegaScaleCredentialRequestJson.class),

        /**
         * <b>Server Endpoint Hook:</b>
         * The pointcut provides the capability to supply a provisioned KeyStore file for TLS base encryption.
         * Note that pointcut {@link #SERVER_CONFIGURATION_KEYSTORE} is invoked only if the endpoint listener
         * is said to required TLS encryption for incoming connections through environment property <b>tls.enabled</b>
         * <p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link java.lang.String} - The keystore password
         * </li>
         * </ul>
         * </p>
         * <p>
         * Interceptors for this pointcut must be registered with the specific
         * endpoint module where the keystore will be used.
         * </p>
         * Hook methods must return <code>KeyStore</code>.
         */
        SERVER_CONFIGURATION_KEYSTORE(KeyStore.class, String.class),

        /**
         * <b>SMART/OIDC Hook:</b>
         * The pointcut is called when a SMART Outbound Security module is configured in
         * federated mode, and there are multiple federated providers configured, prior to
         * the user being asked to select a provider. This pointcut can be used to
         * programmatically select a provider instead of relying on the user to
         * make a selection.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@literal ca.cdr.api.fhir.interceptor.OidcAuthRequestDetails} - This object contains details about the auth request and can be used to extract request parameter values.
         * </li>
         * </ul>
         * </p>
         * Hook methods may return a {@link String}, which should be the Registration ID of an
         * OpenID Connect Server definition (i.e. the value of the "Registration ID" field in the
         * Smile CDR OIDC Server definition page). If the returned String is not {@literal null} and
         * does not match any server definition, the flow will be halted and the user will
         * see an error. If the returned string is {@literal null}, the user will be
         * redirected to a server selection screen.
         */
        SMART_FEDERATED_OIDC_PRE_PROVIDER_SELECTION(String.class, OidcAuthRequestDetails.class),

        /**
         * <b>SMART/OIDC Hook:</b>
         * The pointcut is called when an OIDC client is being saved. This could
         * mean that a new client is being created, or an existing client
         * is being updated or disabled.
         * <p>
         * This hook is called after the database transaction used to
         * save the object has been committed. This means that the record already
         * appears in the database. Any exceptions thrown by hooks for this
         * pointcut may cause an error to appear for the user requesting the
         * operation, but will not affect what has been saved in the database,
         * so no exceptions should be thrown within this pointcut.
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.model.json.IOAuth2ClientDetails} - The Client being saved. Pointcuts should not modify this object.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        SMART_OIDC_CLIENT_SAVED(void.class, IOAuth2ClientDetails.class),

        /**
         * <b>SMART/OIDC Hook:</b>
         * The pointcut is called when an OIDC client is being saved. This could
         * mean that a new client is being created, or an existing client
         * is being updated or disabled.
         * <p>
         * This hook is called within the open database transaction used to
         * save the object. This means that at the time this pointcut is invoked,
         * the record does not yet appear in the database. It also means that any
         * exception thrown by this pointcut will block the operation.
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.model.json.IOAuth2ClientDetails} - The Client being saved. Pointcuts should not modify this object.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        SMART_OIDC_CLIENT_SAVING(void.class, IOAuth2ClientDetails.class),

        /**
         * <b>appSphere Hook:</b>
         * The Pointcut is called when an appSphere admin updates the status of an application or service
         * <p>
         * This hook is called within the open database transaction used to
         * save the object. This means that at the time this pointcut is invoked,
         * the record does not yet appear in the database. It also means that any
         * exception thrown by this pointcut will block the operation.
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link AGConsoleJson} - The application or service being updated. Pointcuts should not modify this object.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        AG_APPLICATION_STATUS_UPDATING(void.class, AGConsoleJson.class),

        /**
         * <b>appSphere Hook:</b>
         * The pointcut is called after an appSphere admin updates the status of an application or service
         * <p>
         * This hook is called after the database transaction used to
         * save the object has been committed. This means that the record already
         * appears in the database. Any exceptions thrown by hooks for this
         * pointcut may cause an error to appear for the user requesting the
         * operation, but will not affect what has been saved in the database,
         * so no exceptions should be thrown within this pointcut.
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link AGConsoleJson} - The application or service that was updated. Pointcuts should not modify this object.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        AG_APPLICATION_STATUS_UPDATED(void.class, AGConsoleJson.class),

        /**
         * <b>appSphere Hook:</b>
         * The Pointcut is called when an appSphere developer registers an application, prior to commiting the registration to the database
         * <p>
         * This hook is called within the open database transaction used to
         * save the object. This means that at the time this pointcut is invoked,
         * the record does not yet appear in the database. It also means that any
         * exception thrown by this pointcut will block the operation.
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link AGApplicationJson} - The application or service being registered. Pointcuts can modify this object.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        AG_APPLICATION_REGISTER(void.class, AGApplicationJson.class),

        /**
         * <b>appSphere Hook:</b>
         * The Pointcut is called when an appSphere developer re-registers an application, prior to commiting the registration to the database
         * <p>
         * This hook is called within the open database transaction used to
         * save the object. This means that at the time this pointcut is invoked,
         * the record does not yet appear in the database. It also means that any
         * exception thrown by this pointcut will block the operation.
         * </p>
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link AGApplicationJson} - The application or service being re-registered. Pointcuts can modify this object.
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        AG_APPLICATION_RE_REGISTER(void.class, AGApplicationJson.class),

        /**
         * <b>System-to-System Data Exchange Hook:</b>
         * This pointcut is called when doing resource matching in the $member-match operation. It provides the ability for
         * clients to execute custom matching JavaScript for the patient matching in $member-match.
         * <p>
         * Hooks may accept the following parameters:
         * <ul>
         * <li>
         * {@link ca.cdr.api.fhir.interceptor.IMemberMatchRequest} - the wrapper request object that contains memberPatient
         * and CoverageToMatch Resources.
         * </li>
         * <li>
         * {@link ca.uhn.fhir.rest.api.server.RequestDetails} - A bean containing details about the request that is about to
         * be processed.
         * </li>
         * </ul>
         * </p>
         * Hook methods may return <code>Patient</code> if a matching patient is found, or <code>void</code> otherwise.
         * Note that if <code>void</code> is returned, then the system will perform the default matching algorithm to try to
         * find any matching patient.
         */
        MEMBER_MATCH(IBaseResource.class, IMemberMatchRequest.class, RequestDetails.class),

        /**
         * <b>Consent Module Hook:</b>
         * <p>This pointcut can be used by customers to add a new implementation of a Consent resource policy.
         * This policy will be used if it is specified in the <code>consentResourcePolicy</code> property of a consent rule.</p>
         * <p>Parameters:</p>
         * <ul>
         * <li>
         * {@link String} The policy name of the IConsentService that will be built. This will come from the <code>consentResourcePolicy</code>
         *      property of a <code>consentRule</code>.
         * </li>
         * <li>
         * {@link IBaseResource} The Consent resource to use to build the IConsentService.
         * </li>
         * <li>
         * {@link UserSessionDetailsJson} The user session details
         * </li>
         * </ul>
         * <p>Return Value:</p>
         * <ul><li>{@link IConsentService} The consent service that should be built from the provided policy name.
         * If an <code>IConsentService</code> cannot be mapped to the provided policy, null should be returned.</li></ul>
         */
        CONSENT_BUILD_CONSENT_RESOURCE_POLICY_CONSENT_SERVICE(
                        IConsentService.class, String.class, IBaseResource.class, UserSessionDetailsJson.class),

        /**
         * <b>Consent Module Hook:</b>
         * <p>This pointcut can be used by customers to add a new implementation of a fixed consent policy.
         * This policy will be used if it is specified in the <code>fixedPolicy</code> property of a consent rule.
         * Unlike a <code>consentResourcePolicy</code>, a <code>fixedPolicy</code> is not dependent on Consent resource.
         * A <code>fixedPolicy</code> can be used to make consent decisions based on the user that is requesting to access a resource.</p>
         * <p>Parameters:</p>
         * <ul>
         * <li>
         * {@link ConsentFixedPolicyRequest} The fixed policy request containing the policy name and a list of parameters. The
         * policy name is the name of the <code>IConsentService</code> that will be built. This will come from the <code>fixedPolicy</code>
         * property of a <code>consentRule</code>.
         * </li>
         * <li>
         * {@link UserSessionDetailsJson} The user session details
         * </li>
         * </ul>
         * <p>Return Value:</p>
         * <ul><li>{@link IConsentService} The consent service that should be built from the provided policy name.
         * If an <code>IConsentService</code> cannot be mapped to the provided policy, null should be returned.</li></ul>
         */
        CONSENT_BUILD_FIXED_POLICY_CONSENT_SERVICE(
                        IConsentService.class, ConsentFixedPolicyRequest.class, UserSessionDetailsJson.class),

        /**
         * <b>Consent Hook:</b>
         * This pointcut can be used by customers to customize the default behavior of the Consent resource-based
         * Consent Service.
         * Add the string representation of the (initial) queries that should be used to fetch consent resources to the {@link ConsentFetchQueries} object.
         * Implementers can use the {@link RequestDetails}, {@link ConsentLookupContext}, {@link IBaseResource}, and {@link UserSessionDetailsJson}
         * to determine the applicable queries.
         * <br/><br/>
         * <b>Note:</b> At least one of the CONSENT_FETCH_QUERIES or CONSENT_ACTIVE_CONSENT_RESOURCES_RESOLVE pointcuts must be implemented. Both pointcuts may also be implemented.
         * <p>
         * The hook can have the following parameters:
         * <ul>
         * <li>
         * {@link ConsentFetchQueries} the object that consent fetch queries should be added to.
         * </li>
         * <li>
         * {@link RequestDetails} the request
         * </li>
         * <li>
         * {@link ConsentLookupContext} the consent context object
         * </li>
         * <li>
         * {@link IBaseResource} the current clinical resource being evaluated for consent.  Will be present for willSeeResource and canSeeResource, but null for startOperation.
         * </li>
         * <li>
         * {@link UserSessionDetailsJson} the user session details.
         * </li>
         * </ul>
         * </p>
         * Hook methods need to add string representations of the consent queries to the {@link ConsentFetchQueries} object. This should
         * consist of one query to have a better performance, but in rare cases multiple queries can be provided.
         */
        CONSENT_FETCH_QUERIES(
                        void.class,
                        ConsentFetchQueries.class,
                        RequestDetails.class,
                        ConsentLookupContext.class,
                        IBaseResource.class,
                        UserSessionDetailsJson.class),

        /**
         * <b>Consent Hook:</b> This pointcut can be used by customers to customize the default behavior of the Consent resource-based
         * Consent Service.
         * Add the Consent resources that should be used for the incoming request to the {@link ConsentActiveResourceResolutionRequest} object.
         * Implementers can use the {@link RequestDetails}, {@link ConsentLookupContext}, {@link IBaseResource}, and {@link UserSessionDetailsJson}
         * to determine the applicable consents.
         * <br/><br/>
         * <b>Note:</b> At least one of the CONSENT_ACTIVE_CONSENT_RESOURCES_RESOLVE or CONSENT_FETCH_QUERIES pointcuts must be implemented. Both pointcuts may also be implemented.
         * <p>
         * The hook can have the following parameters:
         * <ul>
         * <li>
         * {@link ConsentActiveResourceResolutionRequest} the object Consent resources should be added to
         * </li>
         * <li>
         * {@link RequestDetails} the request
         * </li>
         * <li>
         * {@link ConsentLookupContext} the consent context object
         * </li>
         * <li>
         * {@link IBaseResource} the current clinical resource being evaluated for consent.  Will be present for willSeeResource and canSeeResource, but null for startOperation.
         * </li>
         * <li>
         * {@link UserSessionDetailsJson} the user session details.
         * </li>
         * </ul>
         * </p>
         */
        CONSENT_ACTIVE_CONSENT_RESOURCES_RESOLVE(
                        void.class,
                        ConsentActiveResourceResolutionRequest.class,
                        RequestDetails.class,
                        ConsentLookupContext.class,
                        IBaseResource.class,
                        UserSessionDetailsJson.class),

        /**
         * <b>Prior Auth CRD Gather context hook:</b>
         * This pointcut can be used by customers to customize the default behavior of the Prior Auth CRD
         * for determining patientId in Coverage context.
         * <p>
         * The hook can have the following parameters:
         * <ul>
         * <li>
         * {@link CdsServiceRequestJson} the CdsServiceRequestJson from the hook request
         * </li>
         * <li>
         * {@link PriorAuthCrdContextJson} the PriorAuthCrdContextJson to return result i.e. patientId
         * </li>
         * </ul>
         * </p>
         * Hook methods must return <code>void</code>.
         */
        PRIOR_AUTH_CRD_GATHER_CONTEXT(void.class, CdsServiceRequestJson.class, PriorAuthCrdContextJson.class),

        /**
         * <b>Audit Event Pre Persist Hook:</b>
         * The pointcut is invoked right before an audit event is handed off to the persistence layer.
         * <p>
         * This hook is used to select key/value pairs that should be marshalled into a JSON string and saved as
         * additional user information with the audit event.
         * </p>
         *
         * <p>
         * The hook will have the following parameters:
         * <ul>
         * <li>
         * {@link AuditEventJson} the audit event that will be persisted. It is provided for reference only as any modification
         * to the object will be ignored.
         * </li>
         * <li>
         * {@link UserSessionDetailsJson} if present, the object capturing the details pertaining to the user whose actions lead
         * to the audit event which is about to be persisted.
         * </li>
         * <li>
         * {@link OAuth2ClientDetailsJson} if present, the object capturing the details pertaining to the Oauth2 client whose actions lead
         * to the audit event which is about to be persisted.
         * </li>
         * <li>
         * {@link AuditEventPrePersistJson} the parameter object accumulating key/value pairs the client wishes to see
         * added as additional information persisted with the audit event.
         * </li>
         * </ul>
         * </p>
         */
        AUDIT_EVENT_PRE_PERSIST(
                        void.class,
                        "ca.cdr.api.model.json.AuditEventJson",
                        "ca.cdr.api.model.json.UserSessionDetailsJson",
                        "ca.cdr.api.model.json.OAuth2ClientDetailsJson",
                        "ca.cdr.api.model.json.AuditEventPrePersistJson"),

        /**
         * <b>Client Auth Pre Token Hook:</b>
         * The pointcut is invoked right before making the auth token call before member-match and batch-export call. If the
         * token needs to be different than the default client-secret, an OpenIdTokenResponse needs to be returned. The
         * token returned must not be null if the the execution is to continue.
         *
         * <p>
         * The hook will have the following parameters:
         * <ul>
         * <li>
         * {@link HttpRequestBase} the oauth token request to be executed.
         * </li>
         * </ul>
         * </p>
         */
        CLIENT_AUTH_PRE_TOKEN_REQUEST(OpenIdTokenResponse.class, HttpRequestBase.class);

        private final List<String> myParameterTypes;
        private final Class<?> myReturnType;
        private final ExceptionHandlingSpec myExceptionHandlingSpec;

        CdrPointcut(
                        @Nonnull Class<?> theReturnType,
                        @Nonnull ExceptionHandlingSpec theExceptionHandlingSpec,
                        String... theParameterTypes) {

                // This class uses capital-B Boolean for the boolean return type
                assert !theReturnType.equals(boolean.class);

                myReturnType = theReturnType;
                myExceptionHandlingSpec = theExceptionHandlingSpec;
                myParameterTypes = Collections.unmodifiableList(Arrays.asList(theParameterTypes));
        }

        CdrPointcut(@Nonnull Class<?> theReturnType, String... theParameterTypes) {
                this(theReturnType, new ExceptionHandlingSpec(), theParameterTypes);
        }

        CdrPointcut(@Nonnull Class<?> theReturnType, Class<?>... theParameterTypes) {
                this(theReturnType, new ExceptionHandlingSpec(), toNames(theParameterTypes));
        }

        CdrPointcut(@Nonnull Class<?> theReturnType) {
                this(theReturnType, new ExceptionHandlingSpec(), ArrayUtils.EMPTY_STRING_ARRAY);
        }

        CdrPointcut(@Nonnull Class<?> theReturnType, Class<?> theParameterTypes) {
                this(theReturnType, new ExceptionHandlingSpec(), theParameterTypes.getName());
        }

        private static String[] toNames(Class<?>[] theParameterTypes) {
                return Arrays.stream(theParameterTypes)
                                .map(Class::getName)
                                .collect(Collectors.toList())
                                .toArray(new String[0]);
        }

        @Override
        public boolean isShouldLogAndSwallowException(@Nonnull Throwable theException) {
                for (Class<? extends Throwable> next : myExceptionHandlingSpec.myTypesToLogAndSwallow) {
                        if (next.isAssignableFrom(theException.getClass())) {
                                return true;
                        }
                }
                return false;
        }

        @Override
        @Nonnull
        public Class<?> getReturnType() {
                return myReturnType;
        }

        @Override
        public Class<?> getBooleanReturnTypeForEnum() {
                return Boolean.class;
        }

        @Override
        @Nonnull
        public List<String> getParameterTypes() {
                return myParameterTypes;
        }

        private static class ExceptionHandlingSpec {

                private final Set<Class<? extends Throwable>> myTypesToLogAndSwallow = new HashSet<>();

                ExceptionHandlingSpec addLogAndSwallow(@Nonnull Class<? extends Throwable> theType) {
                        myTypesToLogAndSwallow.add(theType);
                        return this;
                }
        }
}