protected void registerMultifactorTrustedAuthentication(final FlowDefinitionRegistry registry) {
        validateFlowDefinitionConfiguration();

        LOGGER.trace("Flow definitions found in the registry are [{}]", (Object[]) registry.getFlowDefinitionIds());
        val flowId = Arrays.stream(registry.getFlowDefinitionIds()).findFirst().orElseThrow();
        LOGGER.trace("Processing flow definition [{}]", flowId);

        val flow = (Flow) registry.getFlowDefinition(flowId);
        Assert.notNull(flow, String.format("%s flow cannot be null or undefined", flowId));

        val state = getState(flow, CasWebflowConstants.STATE_ID_INIT_LOGIN_FORM, ActionState.class);
        Assert.notNull(state, String.format("%s state cannot be null or undefined", CasWebflowConstants.STATE_ID_INIT_LOGIN_FORM));

        val transition = (Transition) state.getTransition(CasWebflowConstants.TRANSITION_ID_SUCCESS);
        Assert.notNull(state, String.format("%s transition cannot be null or undefined", CasWebflowConstants.TRANSITION_ID_SUCCESS));

        val targetStateId = transition.getTargetStateId();
        transition.setTargetStateResolver(new DefaultTargetStateResolver(CasWebflowConstants.STATE_ID_VERIFY_TRUSTED_DEVICE));
        val verifyAction = createActionState(flow, CasWebflowConstants.STATE_ID_VERIFY_TRUSTED_DEVICE,
            CasWebflowConstants.ACTION_ID_MFA_VERIFY_TRUST_ACTION);
        val enableDeviceRegistration = casProperties.getAuthn().getMfa().getTrusted().getCore().isDeviceRegistrationEnabled();
        if (enableDeviceRegistration) {
            LOGGER.trace("Device registration is turned on for multifactor flow [{}]", flowId);
            createTransitionForState(verifyAction, CasWebflowConstants.TRANSITION_ID_YES,
                CasWebflowConstants.STATE_ID_FINISH_MFA_TRUSTED_AUTH);
        } else {
            createTransitionForState(verifyAction, CasWebflowConstants.TRANSITION_ID_YES, CasWebflowConstants.STATE_ID_REAL_SUBMIT);
        }
        createTransitionForState(verifyAction, CasWebflowConstants.TRANSITION_ID_NO, targetStateId);
        createTransitionForState(verifyAction, CasWebflowConstants.TRANSITION_ID_SKIP, targetStateId);

        val submit = getState(flow, CasWebflowConstants.STATE_ID_REAL_SUBMIT, ActionState.class);

        val success = (Transition) submit.getTransition(CasWebflowConstants.TRANSITION_ID_SUCCESS);
        Assert.notNull(state, String.format("%s transition cannot be null or undefined", CasWebflowConstants.TRANSITION_ID_SUCCESS));
        if (enableDeviceRegistration) {
            success.setTargetStateResolver(new DefaultTargetStateResolver(CasWebflowConstants.STATE_ID_PREPARE_REGISTER_TRUSTED_DEVICE));
        } else {
            success.setTargetStateResolver(new DefaultTargetStateResolver(CasWebflowConstants.STATE_ID_REGISTER_TRUSTED_DEVICE));
        }

        createRegisterDeviceView(flow);

        val registerAction = createActionState(flow, CasWebflowConstants.STATE_ID_REGISTER_TRUSTED_DEVICE,
            CasWebflowConstants.ACTION_ID_MFA_SET_TRUST_ACTION);
        createStateDefaultTransition(registerAction, CasWebflowConstants.STATE_ID_SUCCESS);
        Assert.isTrue(submit.getActionList().size() > 0, "There are no actions defined for " + flowId);
        val act = submit.getActionList().iterator().next();
        val finishMfaTrustedAuth = createActionState(flow, CasWebflowConstants.STATE_ID_FINISH_MFA_TRUSTED_AUTH, act);
        val finishedTransition = createTransition(CasWebflowConstants.TRANSITION_ID_SUCCESS, CasWebflowConstants.STATE_ID_SUCCESS);
        finishMfaTrustedAuth.getTransitionSet().add(finishedTransition);
        createStateDefaultTransition(finishMfaTrustedAuth, CasWebflowConstants.STATE_ID_SUCCESS);
    }
Register multifactor trusted authentication.

@param registry the registry
support/cas-server-support-trusted-mfa-core/src/main/java/org/apereo/cas/trusted/web/flow/AbstractMultifactorTrustedDeviceWebflowConfigurer.java