sapiopycommons 2025.7.1a575__py3-none-any.whl → 2025.7.2a578__py3-none-any.whl

sapiopycommons/callbacks/callback_util.py

@@ -4,8 +4,7 @@ import io
 import re
 import warnings
 from copy import copy
-from enum import Enum
-from typing import Iterable, TypeAlias, Any, Callable, Container, Collection
+from typing import Iterable, TypeAlias, Any, Callable
 from weakref import WeakValueDictionary
 
 from requests import ReadTimeout
@@ -39,35 +38,11 @@ from sapiopycommons.general.aliases import FieldMap, SapioRecord, AliasUtil, Rec
 from sapiopycommons.general.custom_report_util import CustomReportUtil
 from sapiopycommons.general.exceptions import SapioUserCancelledException, SapioException, SapioUserErrorException, \
     SapioDialogTimeoutException
-from sapiopycommons.general.time_util import TimeUtil
 from sapiopycommons.recordmodel.record_handler import RecordHandler
 
 DataTypeLayoutIdentifier: TypeAlias = DataTypeLayout | str | None
 
 
-# FR-47690: Added enum to customize blank handling result behavior, instead of using the require_selection/input
-# boolean parameter.
-class BlankResultHandling(Enum):
-    """
-    An enum that controls how blank results are handled in dialogs.
-    """
-    DEFAULT = 0
-    """Used only by dialog functions. If a dialog function parameter is set to this value, then the blank result
-    handling of the CallbackUtil is used."""
-    REPEAT = 1
-    """If the user provides a blank result, repeat the dialog."""
-    CANCEL = 2
-    """If the user provides a blank result, throw a cancel exception."""
-    RETURN = 3
-    """If the user provides a blank result, return it to the caller."""
-
-
-# CR-47521: Updated various parameter type hints from list or Iterable to more specific type hints.
-# If we need to iterate over the parameter, then it is Iterable.
-# If we need to see if the parameter contains a value, then it is Container.
-# If the length/size of the parameter is needed, then it is Collection.
-# If we need to access the parameter by an index, then it is Sequence. (This excludes sets and dictionaries, so it's
-# probably better to accept a Collection then cast the parameter to a list if you need to get an element from it.)
 class CallbackUtil:
     user: SapioUser
     callback: ClientCallback
@@ -78,7 +53,6 @@ class CallbackUtil:
     timeout_seconds: int
     width_pixels: int | None
     width_percent: float | None
-    _default_blank_result_handling: BlankResultHandling
 
     __instances: WeakValueDictionary[SapioUser, CallbackUtil] = WeakValueDictionary()
     __initialized: bool
@@ -116,7 +90,6 @@ class CallbackUtil:
         self.timeout_seconds = self.user.timeout_seconds
         self.width_pixels = None
         self.width_percent = None
-        self._default_blank_result_handling = BlankResultHandling.CANCEL
         self.__layouts = {}
 
     def set_dialog_width(self, width_pixels: int | None = None, width_percent: float | None = None):
@@ -143,19 +116,6 @@ class CallbackUtil:
         """
         self.timeout_seconds = timeout
 
-    def set_default_blank_result_handling(self, handling: BlankResultHandling):
-        """
-        Set the default handling of blank results provided by the user in certain dialogs. This will only be used
-        if the dialog functions have their own blank_result_handling parameter set to DEFAULT.
-
-        :param handling: The handling to use for blank results in dialogs.
-        """
-        if not isinstance(handling, BlankResultHandling):
-            raise SapioException("Invalid blank result handling provided.")
-        if handling == BlankResultHandling.DEFAULT:
-            raise SapioException("Blank result handling cannot be set to DEFAULT.")
-        self._default_blank_result_handling = handling
-
     def toaster_popup(self, message: str, title: str = "", popup_type: PopupType = PopupType.Info) -> None:
         """
         Display a toaster popup in the bottom right corner of the user's screen.
@@ -217,7 +177,7 @@ class CallbackUtil:
         # Send the request to the user.
         request = OptionDialogRequest(title, msg, options, default_option, user_can_cancel,
                                       width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-        response: int = self.__send_dialog(request, self.callback.show_option_dialog)
+        response: int = self.__handle_dialog_request(request, self.callback.show_option_dialog)
         return options[response]
 
     def ok_dialog(self, title: str, msg: str) -> None:
@@ -233,7 +193,7 @@ class CallbackUtil:
     def ok_cancel_dialog(self, title: str, msg: str, default_ok: bool = True) -> bool:
         """
         Create an option dialog where the only options are "OK" and "Cancel". Doesn't allow the user to cancel the
-        dialog using the X in the top right corner.
+        dialog using the X at the top right corner.
 
         :param title: The title of the dialog.
         :param msg: The message to display in the dialog. This can be formatted using HTML elements.
@@ -245,7 +205,7 @@ class CallbackUtil:
     def yes_no_dialog(self, title: str, msg: str, default_yes: bool = True) -> bool:
         """
         Create an option dialog where the only options are "Yes" and "No". Doesn't allow the user to cancel the
-        dialog using the X in the top right corner.
+        dialog using the X at the top right corner.
 
         :param title: The title of the dialog.
         :param msg: The message to display in the dialog. This can be formatted using HTML elements.
@@ -254,46 +214,16 @@ class CallbackUtil:
         """
         return self.option_dialog(title, msg, ["Yes", "No"], 0 if default_yes else 1, False) == "Yes"
 
-    # FR-47690: Added function.
-    def accept_decline_dialog(self, title: str, msg: str, default_accept: bool = True) -> bool:
-        """
-        Create an option dialog where the only options are "Accept" and "Decline". Doesn't allow the user to cancel the
-        dialog using the X in the top right corner.
-
-        :param title: The title of the dialog.
-        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
-        :param default_accept: If true, "Accept" is the default choice. Otherwise, the default choice is "Decline".
-        :return: True if the user selected Accept. False if the user selected Decline.
-        """
-        return self.option_dialog(title, msg, ["Accept", "Decline"], 0 if default_accept else 1, False) == "Accept"
-
-    # FR-47690: Added function.
-    def confirm_deny_dialog(self, title: str, msg: str, default_confirm: bool = True) -> bool:
-        """
-        Create an option dialog where the only options are "Confirm" and "Deny". Doesn't allow the user to cancel the
-        dialog using the X in the top right corner.
-
-        :param title: The title of the dialog.
-        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
-        :param default_confirm: If true, "Confirm" is the default choice. Otherwise, the default choice is "Deny".
-        :return: True if the user selected Confirm. False if the user selected Deny.
-        """
-        return self.option_dialog(title, msg, ["Confirm", "Deny"], 0 if default_confirm else 1, False) == "Confirm"
-
     # CR-47310: Add a parameter to the list, input, selection, and e-sign dialog functions to control reprompting the
     # user if no input/selection/valid credentials are provided.
-    # FR-47690: Added shortcut_single_option parameter. Updated with blank result handling behavior.
     def list_dialog(self,
                     title: str,
                     options: Iterable[str],
                     multi_select: bool = False,
                     preselected_values: Iterable[str] | None = None,
                     *,
-                    shortcut_single_option: bool = True,
-                    require_selection = None,
-                    blank_result_handling: BlankResultHandling = BlankResultHandling.DEFAULT,
-                    repeat_message: str | None = "Please provide a selection to continue.",
-                    cancel_message: str | None = "No selection was provided. Cancelling dialog.") -> list[str]:
+                    require_selection: bool = False,
+                    repeat_message: str | None = "Please provide a selection to continue.") -> list[str]:
         """
         Create a list dialog with the given options for the user to choose from.
 
@@ -302,237 +232,33 @@ class CallbackUtil:
         :param multi_select: Whether the user is able to select multiple options from the list.
         :param preselected_values: A list of values that will already be selected when the list dialog is created. The
             user can unselect these values if they want to.
-        :param shortcut_single_option: If true, then if the list contains only one option, the dialog will not be shown
-            and the single option will be returned immediately.
-        :param require_selection: DEPRECATED. Use blank_result_handling with a value of BlankResultHandling.REPEAT
-            instead.
-        :param blank_result_handling: Determine how to handle the result of a callback when the user provides a blank
-            result.
-        :param repeat_message: If blank_result_handling is REPEAT and a repeat_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
-        :param cancel_message: If blank_result_handling is CANCEL and a cancel_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
+        :param require_selection: If true, the request will be re-sent if the user submits the dialog without making
+            a selection.
+        :param repeat_message: If require_selection is true and a repeat_message is provided, then that message appears
+            as toaster text if the dialog is repeated.
         :return: The list of options that the user selected.
         """
         if not options:
             raise SapioException("No options provided.")
-        options = list(options)
-        if len(options) == 1 and shortcut_single_option:
-            return [options[0]]
 
         # Send the request to the user.
-        request = ListDialogRequest(title, multi_select, options,
+        request = ListDialogRequest(title, multi_select, list(options),
                                     list(preselected_values) if preselected_values else None,
                                     width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
 
-        # Reverse compatibility: If require_selection is true and blank_result_handling is not set, then
-        # set blank_result_handling to REPEAT.
-        if require_selection is True and blank_result_handling == BlankResultHandling.DEFAULT:
-            blank_result_handling = BlankResultHandling.REPEAT
-        def not_blank_func(r: list[str]) -> bool:
-            return bool(r)
-        return self.__send_dialog_blank_results(request, self.callback.show_list_dialog, not_blank_func,
-                                                blank_result_handling, repeat_message, cancel_message)
-
-    # FR-47690: Updated with blank result handling behavior.
-    def input_dialog(self,
-                     title: str,
-                     msg: str,
-                     field: AbstractVeloxFieldDefinition,
-                     *,
-                     require_input = None,
-                     blank_result_handling: BlankResultHandling = BlankResultHandling.DEFAULT,
-                     repeat_message: str | None = "Please provide a value to continue.",
-                     cancel_message: str | None = "No input was provided. Cancelling dialog.") -> FieldValue:
-        """
-        Create an input dialog where the user must input data for a singular field.
-
-        :param title: The title of the dialog.
-        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
-        :param field: The definition for a field that the user must provide input to.
-        :param require_input: DEPRECATED. Use blank_result_handling with a value of BlankResultHandling.REPEAT
-            instead.
-        :param blank_result_handling: Determine how to handle the result of a callback when the user provides a blank
-            result.
-        :param repeat_message: If blank_result_handling is REPEAT and a repeat_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
-        :param cancel_message: If blank_result_handling is CANCEL and a cancel_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
-        :return: The response value from the user for the given field.
-        """
-        # Send the request to the user.
-        request = InputDialogCriteria(title, msg, field,
-                                      width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-
-        # Reverse compatibility: If require_selection is true and blank_result_handling is not set, then
-        # set blank_result_handling to REPEAT.
-        handling = blank_result_handling
-        if require_input is True and handling == BlankResultHandling.DEFAULT:
-            handling = BlankResultHandling.REPEAT
-        if handling == BlankResultHandling.DEFAULT or handling is None:
-            handling = self._default_blank_result_handling
-
+        # If require_selection is true, repeat the request if the user didn't make a selection.
         while True:
-            try:
-                self.user.timeout_seconds = self.timeout_seconds
-                # It's not possible to distinguish between the user cancelling this dialog and submitting the dialog
-                # with no input if the ClientCallback show_input_dialog function is used, as both cases just return
-                # None. Therefore, in order to be able to make that distinction, we need to call the endpoint without
-                # ClientCallback and get the raw response object.
-                raw_response = self.user.post('/clientcallback/showInputDialog', payload=request.to_json())
-                # A response status code of 204 is what represents a cancelled dialog.
-                if raw_response.status_code == 204:
-                    raise SapioUserCancelledException()
-                self.user.raise_for_status(raw_response)
-                json_dct: dict | None = self.user.get_json_data_or_none(raw_response)
-                response: FieldValue = json_dct['result'] if json_dct else None
-            except ReadTimeout:
-                raise SapioDialogTimeoutException()
-            finally:
-                self.user.timeout_seconds = self._original_timeout
-
-            # String fields that the user didn't provide will return as an empty string instead of a None response.
-            is_str: bool = isinstance(response, str)
-            if (is_str and response) or (not is_str and response is not None):
-                return response
-
-            match handling:
-                case BlankResultHandling.CANCEL:
-                    # If the user provided no selection, throw an exception.
-                    if cancel_message:
-                        self.toaster_popup(cancel_message, popup_type=PopupType.Warning)
-                    raise SapioUserCancelledException()
-                case BlankResultHandling.REPEAT:
-                    # If the user provided no selection, repeat the dialog.
-                    # If a repeatMessage is provided, display it as a toaster popup.
-                    if repeat_message:
-                        self.toaster_popup(repeat_message, popup_type=PopupType.Warning)
-                case BlankResultHandling.RETURN:
-                    # If the user provided no selection, return the blank result.
-                    return response
-
-    def string_input_dialog(self,
-                            title: str,
-                            msg: str,
-                            field_name: str,
-                            default_value: str | None = None,
-                            max_length: int | None = None,
-                            editable: bool = True,
-                            *,
-                            require_input: bool = False,
-                            repeat_message: str | None = "Please provide a value to continue.",
-                            **kwargs) -> str:
-        """
-        Create an input dialog where the user must input data for a singular text field.
-
-        :param title: The title of the dialog.
-        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
-        :param field_name: The name and display name of the string field.
-        :param default_value: The default value to place into the string field, if any.
-        :param max_length: The max length of the string value. If not provided, uses the length of the default value.
-            If neither this nor a default value are provided, defaults to 100 characters.
-        :param editable: Whether the field is editable by the user.
-        :param require_input: If true, the request will be re-sent if the user submits the dialog without making
-            a selection.
-        :param repeat_message: If require_input is true and a repeat_message is provided, then that message appears
-            as toaster text if the dialog is repeated.
-        :param kwargs: Any additional keyword arguments to pass to the field definition.
-        :return: The string that the user input into the dialog.
-        """
-        # FR-47690: Deprecated in favor of suggesting the use of the FieldBuilder to customize an input_dialog's field.
-        warnings.warn("Deprecated. Use the base input_dialog function and the FieldBuilder class to construct the "
-                      "input field.", DeprecationWarning)
-        if max_length is None:
-            max_length = len(default_value) if default_value else 100
-        field = VeloxStringFieldDefinition("Input", field_name, field_name, default_value=default_value,
-                                           max_length=max_length, editable=editable, **kwargs)
-        return self.input_dialog(title, msg, field,
-                                 require_input=require_input, repeat_message=repeat_message)
-
-    def integer_input_dialog(self,
-                             title: str,
-                             msg: str,
-                             field_name: str,
-                             default_value: int = None,
-                             min_value: int = -10000,
-                             max_value: int = 10000,
-                             editable: bool = True,
-                             *,
-                             require_input: bool = False,
-                             repeat_message: str | None = "Please provide a value to continue.",
-                             **kwargs) -> int:
-        """
-        Create an input dialog where the user must input data for a singular integer field.
-
-        :param title: The title of the dialog.
-        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
-        :param field_name: The name and display name of the integer field.
-        :param default_value: The default value to place into the integer field. If not provided, defaults to the 0 or
-            the minimum value, whichever is higher.
-        :param min_value: The minimum allowed value of the input.
-        :param max_value: The maximum allowed value of the input.
-        :param editable: Whether the field is editable by the user.
-        :param require_input: If true, the request will be re-sent if the user submits the dialog without making
-            a selection.
-        :param repeat_message: If require_input is true and a repeat_message is provided, then that message appears
-            as toaster text if the dialog is repeated.
-        :param kwargs: Any additional keyword arguments to pass to the field definition.
-        :return: The integer that the user input into the dialog.
-        """
-        # FR-47690: Deprecated in favor of suggesting the use of the FieldBuilder to customize an input_dialog's field.
-        warnings.warn("Deprecated. Use the base input_dialog function and the FieldBuilder class to construct the "
-                      "input field.", DeprecationWarning)
-        if default_value is None:
-            default_value = max(0, min_value)
-        field = VeloxIntegerFieldDefinition("Input", field_name, field_name, default_value=default_value,
-                                            min_value=min_value, max_value=max_value, editable=editable, **kwargs)
-        return self.input_dialog(title, msg, field,
-                                 require_input=require_input, repeat_message=repeat_message)
-
-    def double_input_dialog(self,
-                            title: str,
-                            msg: str,
-                            field_name: str,
-                            default_value: float = None,
-                            min_value: float = -10000000,
-                            max_value: float = 100000000,
-                            editable: bool = True,
-                            *,
-                            require_input: bool = False,
-                            repeat_message: str | None = "Please provide a value to continue.",
-                            **kwargs) -> float:
-        """
-        Create an input dialog where the user must input data for a singular double field.
-
-        :param title: The title of the dialog.
-        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
-        :param field_name: The name and display name of the double field.
-        :param default_value: The default value to place into the double field. If not provided, defaults to the 0 or
-            the minimum value, whichever is higher.
-        :param min_value: The minimum allowed value of the input.
-        :param max_value: The maximum allowed value of the input.
-        :param editable: Whether the field is editable by the user.
-        :param require_input: If true, the request will be re-sent if the user submits the dialog without making
-            a selection.
-        :param repeat_message: If require_input is true and a repeat_message is provided, then that message appears
-            as toaster text if the dialog is repeated.
-        :param kwargs: Any additional keyword arguments to pass to the field definition.
-        :return: The float that the user input into the dialog.
-        """
-        # FR-47690: Deprecated in favor of suggesting the use of the FieldBuilder to customize an input_dialog's field.
-        warnings.warn("Deprecated. Use the base input_dialog function and the FieldBuilder class to construct the "
-                      "input field.", DeprecationWarning)
-        if default_value is None:
-            default_value = max(0., min_value)
-        field = VeloxDoubleFieldDefinition("Input", field_name, field_name, default_value=default_value,
-                                           min_value=min_value, max_value=max_value, editable=editable, **kwargs)
-        return self.input_dialog(title, msg, field,
-                                 require_input=require_input, repeat_message=repeat_message)
+            response: list[str] = self.__handle_dialog_request(request, self.callback.show_list_dialog)
+            if not require_selection or response:
+                break
+            if repeat_message:
+                self.toaster_popup(repeat_message, popup_type=PopupType.Warning)
+        return response
 
     def form_dialog(self,
                     title: str,
                     msg: str,
-                    fields: Iterable[AbstractVeloxFieldDefinition],
+                    fields: list[AbstractVeloxFieldDefinition],
                     values: FieldMap = None,
                     column_positions: dict[str, tuple[int, int]] = None,
                     *,
@@ -547,8 +273,7 @@ class CallbackUtil:
         :param msg: The message to display at the top of the form. This can be formatted using HTML elements.
         :param fields: The definitions of the fields to display in the form. Fields will be displayed in the order they
             are provided in this list.
-        :param values: Sets the default values of the fields. If a field name from the fields parameter is not
-            provided in this dictionary, it will be initialized with its default value.
+        :param values: Sets the default values of the fields.
         :param column_positions: If a tuple is provided for a field name, alters that field's column position and column
             span. (Field order is still determined by the fields list.)
         :param data_type: The data type name for the temporary data type that will be created for this form.
@@ -562,23 +287,16 @@ class CallbackUtil:
         # Build a temporary data type for the request.
         temp_dt = self.__temp_dt_from_field_defs(data_type, display_name, plural_display_name, fields, column_positions)
 
-        # FR-47690: Set default values for fields that aren't present.
-        if values is None:
-            values = {}
-        for field in fields:
-            if field.data_field_name not in values:
-                values[field.data_field_name] = field.default_value
-
         # Send the request to the user.
         request = FormEntryDialogRequest(title, msg, temp_dt, values,
                                          width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-        response: FieldMap = self.__send_dialog(request, self.callback.show_form_entry_dialog)
+        response: FieldMap = self.__handle_dialog_request(request, self.callback.show_form_entry_dialog)
         return response
 
     def record_form_dialog(self,
                            title: str,
                            msg: str,
-                           fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                           fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
                            record: SapioRecord,
                            column_positions: dict[str, tuple[int, int]] | None = None,
                            editable=None,
@@ -644,14 +362,14 @@ class CallbackUtil:
         # Send the request to the user.
         request = FormEntryDialogRequest(title, msg, temp_dt, values,
                                          width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-        response: FieldMap = self.__send_dialog(request, self.callback.show_form_entry_dialog)
+        response: FieldMap = self.__handle_dialog_request(request, self.callback.show_form_entry_dialog)
         return response
 
     # FR-47314: Create record form and table dialogs for updating or creating records.
     def set_record_form_dialog(self,
                                title: str,
                                msg: str,
-                               fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                               fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
                                record: SapioRecord,
                                column_positions: dict[str, tuple[int, int]] | None = None,
                                *,
@@ -694,7 +412,7 @@ class CallbackUtil:
     def create_record_form_dialog(self,
                                   title: str,
                                   msg: str,
-                                  fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                                  fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
                                   wrapper_type: type[WrappedType] | str,
                                   column_positions: dict[str, tuple[int, int]] | None = None,
                                   *,
@@ -738,17 +456,176 @@ class CallbackUtil:
                                     default_modifier=default_modifier, field_modifiers=field_modifiers)
         return record
 
+    def input_dialog(self,
+                     title: str,
+                     msg: str,
+                     field: AbstractVeloxFieldDefinition,
+                     *,
+                     require_input: bool = False,
+                     repeat_message: str | None = "Please provide a value to continue.") -> FieldValue:
+        """
+        Create an input dialog where the user must input data for a singular field.
+
+        :param title: The title of the dialog.
+        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
+        :param field: The definition for a field that the user must provide input to.
+        :param require_input: If true, the request will be re-sent if the user submits the dialog without providing an
+            input field value.
+        :param repeat_message: If require_input is true and a repeat_message is provided, then that message appears
+            as toaster text if the dialog is repeated.
+        :return: The response value from the user for the given field.
+        """
+        # Send the request to the user.
+        request = InputDialogCriteria(title, msg, field,
+                                      width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+
+        # If require_input is true, repeat the request if the user didn't provide a field value.
+        while True:
+            try:
+                self.user.timeout_seconds = self.timeout_seconds
+                # It's not possible to distinguish between the user cancelling this dialog and submitting the dialog
+                # with no input if the ClientCallback show_input_dialog function is used, as both cases just return
+                # None. Therefore, in order to be able to make that distinction, we need to call the endpoint without
+                # ClientCallback and get the raw response object.
+                raw_response = self.user.post('/clientcallback/showInputDialog', payload=request.to_json())
+                # A response status code of 204 is what represents a cancelled dialog.
+                if raw_response.status_code == 204:
+                    raise SapioUserCancelledException()
+                self.user.raise_for_status(raw_response)
+                json_dct: dict | None = self.user.get_json_data_or_none(raw_response)
+                response: FieldValue = json_dct['result'] if json_dct else None
+            except ReadTimeout:
+                raise SapioDialogTimeoutException()
+            finally:
+                self.user.timeout_seconds = self._original_timeout
+            # String fields that the user didn't provide will return as an empty string instead of a None response.
+            is_str: bool = isinstance(response, str)
+            if not require_input or (is_str and response) or (not is_str and response is not None):
+                break
+            if repeat_message:
+                self.toaster_popup(repeat_message, popup_type=PopupType.Warning)
+        return response
+
+    def string_input_dialog(self,
+                            title: str,
+                            msg: str,
+                            field_name: str,
+                            default_value: str | None = None,
+                            max_length: int | None = None,
+                            editable: bool = True,
+                            *,
+                            require_input: bool = False,
+                            repeat_message: str | None = "Please provide a value to continue.",
+                            **kwargs) -> str:
+        """
+        Create an input dialog where the user must input data for a singular text field.
+
+        :param title: The title of the dialog.
+        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
+        :param field_name: The name and display name of the string field.
+        :param default_value: The default value to place into the string field, if any.
+        :param max_length: The max length of the string value. If not provided, uses the length of the default value.
+            If neither this nor a default value are provided, defaults to 100 characters.
+        :param editable: Whether the field is editable by the user.
+        :param require_input: If true, the request will be re-sent if the user submits the dialog without making
+            a selection.
+        :param repeat_message: If require_input is true and a repeat_message is provided, then that message appears
+            as toaster text if the dialog is repeated.
+        :param kwargs: Any additional keyword arguments to pass to the field definition.
+        :return: The string that the user input into the dialog.
+        """
+        if max_length is None:
+            max_length = len(default_value) if default_value else 100
+        field = VeloxStringFieldDefinition("Input", field_name, field_name, default_value=default_value,
+                                           max_length=max_length, editable=editable, **kwargs)
+        return self.input_dialog(title, msg, field,
+                                 require_input=require_input, repeat_message=repeat_message)
+
+    def integer_input_dialog(self,
+                             title: str,
+                             msg: str,
+                             field_name: str,
+                             default_value: int = None,
+                             min_value: int = -10000,
+                             max_value: int = 10000,
+                             editable: bool = True,
+                             *,
+                             require_input: bool = False,
+                             repeat_message: str | None = "Please provide a value to continue.",
+                             **kwargs) -> int:
+        """
+        Create an input dialog where the user must input data for a singular integer field.
+
+        :param title: The title of the dialog.
+        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
+        :param field_name: The name and display name of the integer field.
+        :param default_value: The default value to place into the integer field. If not provided, defaults to the 0 or
+            the minimum value, whichever is higher.
+        :param min_value: The minimum allowed value of the input.
+        :param max_value: The maximum allowed value of the input.
+        :param editable: Whether the field is editable by the user.
+        :param require_input: If true, the request will be re-sent if the user submits the dialog without making
+            a selection.
+        :param repeat_message: If require_input is true and a repeat_message is provided, then that message appears
+            as toaster text if the dialog is repeated.
+        :param kwargs: Any additional keyword arguments to pass to the field definition.
+        :return: The integer that the user input into the dialog.
+        """
+        if default_value is None:
+            default_value = max(0, min_value)
+        field = VeloxIntegerFieldDefinition("Input", field_name, field_name, default_value=default_value,
+                                            min_value=min_value, max_value=max_value, editable=editable, **kwargs)
+        return self.input_dialog(title, msg, field,
+                                 require_input=require_input, repeat_message=repeat_message)
+
+    def double_input_dialog(self,
+                            title: str,
+                            msg: str,
+                            field_name: str,
+                            default_value: float = None,
+                            min_value: float = -10000000,
+                            max_value: float = 100000000,
+                            editable: bool = True,
+                            *,
+                            require_input: bool = False,
+                            repeat_message: str | None = "Please provide a value to continue.",
+                            **kwargs) -> float:
+        """
+        Create an input dialog where the user must input data for a singular double field.
+
+        :param title: The title of the dialog.
+        :param msg: The message to display in the dialog. This can be formatted using HTML elements.
+        :param field_name: The name and display name of the double field.
+        :param default_value: The default value to place into the double field. If not provided, defaults to the 0 or
+            the minimum value, whichever is higher.
+        :param min_value: The minimum allowed value of the input.
+        :param max_value: The maximum allowed value of the input.
+        :param editable: Whether the field is editable by the user.
+        :param require_input: If true, the request will be re-sent if the user submits the dialog without making
+            a selection.
+        :param repeat_message: If require_input is true and a repeat_message is provided, then that message appears
+            as toaster text if the dialog is repeated.
+        :param kwargs: Any additional keyword arguments to pass to the field definition.
+        :return: The float that the user input into the dialog.
+        """
+        if default_value is None:
+            default_value = max(0., min_value)
+        field = VeloxDoubleFieldDefinition("Input", field_name, field_name, default_value=default_value,
+                                           min_value=min_value, max_value=max_value, editable=editable, **kwargs)
+        return self.input_dialog(title, msg, field,
+                                 require_input=require_input, repeat_message=repeat_message)
+
     def table_dialog(self,
                      title: str,
                      msg: str,
-                     fields: Iterable[AbstractVeloxFieldDefinition],
-                     values: Iterable[FieldMap] | int,
+                     fields: list[AbstractVeloxFieldDefinition],
+                     values: list[FieldMap],
                      *,
                      data_type: DataTypeIdentifier = "Default",
                      display_name: str | None = None,
                      plural_display_name: str | None = None,
                      group_by: FieldIdentifier | None = None,
-                     image_data: Iterable[bytes] | None = None) -> list[FieldMap]:
+                     image_data: list[bytes] | None = None) -> list[FieldMap]:
         """
         Create a table dialog where the user may input data into the fields of the table. Requires that the caller
         provide the definitions of every field in the table.
@@ -757,8 +634,7 @@ class CallbackUtil:
         :param msg: The message to display at the top of the form. This can be formatted using HTML elements.
         :param fields: The definitions of the fields to display as table columns. Fields will be displayed in the order
             they are provided in this list.
-        :param values: The values to set for each row of the table. If an integer is provided, it is treated as the
-            number of rows to create in the table, with each row using the default values of the field definitions.
+        :param values: The values to set for each row of the table.
         :param group_by: If provided, the created table dialog will be grouped by the field with this name by default.
             The user may remove this grouping if they want to.
         :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
@@ -771,18 +647,9 @@ class CallbackUtil:
         :return: A list of dictionaries mapping the data field names of the given field definitions to the response
             value from the user for that field for each row.
         """
-        # FR-47690: Accept an integer as the values parameter to create a table with that many rows.
-        if isinstance(values, int):
-            values: list[dict[str, Any]] = [{} for _ in range(values)]
         if not values:
             raise SapioException("No values provided.")
 
-        # FR-47690: Set default values for fields that aren't present.
-        for row in values:
-            for field in fields:
-                if field.data_field_name not in row:
-                    row[field.data_field_name] = field.default_value
-
         # Convert the group_by parameter to a field name.
         if group_by is not None:
             group_by: str = AliasUtil.to_data_field_name(group_by)
@@ -793,24 +660,23 @@ class CallbackUtil:
         temp_dt.record_image_assignable = bool(image_data)
 
         # Send the request to the user.
-        request = TableEntryDialogRequest(title, msg, temp_dt, list(values),
+        request = TableEntryDialogRequest(title, msg, temp_dt, values,
                                           record_image_data_list=image_data, group_by_field=group_by,
                                           width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-        response: list[FieldMap] = self.__send_dialog(request, self.callback.show_table_entry_dialog)
+        response: list[FieldMap] = self.__handle_dialog_request(request, self.callback.show_table_entry_dialog)
         return response
 
     def record_table_dialog(self,
                             title: str,
                             msg: str,
-                            fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
-                            records: Iterable[SapioRecord],
+                            fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                            records: list[SapioRecord],
                             editable=None,
                             *,
                             default_modifier: FieldModifier | None = None,
                             field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                             group_by: FieldIdentifier | None = None,
-                            image_data: Iterable[bytes] | None = None,
-                            index_field: str | None = None) -> list[FieldMap]:
+                            image_data: list[bytes] | None = None) -> list[FieldMap]:
         """
         Create a table dialog where the user may input data into the fields of the table. The table is constructed from
         a given list of records of a singular type.
@@ -840,12 +706,6 @@ class CallbackUtil:
             The user may remove this grouping if they want to.
         :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
             the image data list corresponds to the element at the same index in the records list.
-        :param index_field: If provided, the returned field maps will contain a field with this name that is equal to
-            the record ID of the record at the same index in the records list. This can be used to map the results
-            back to the original records. This is used instead of using a RecordId field, as the RecordId field has
-            special behavior in the system that can cause issues if the given records are uncommitted record models
-            with negative record IDs, meaning we don't want to have a RecordId field in the field maps provided to the
-            system.
         :return: A list of dictionaries mapping the data field names of the given field definitions to the response
             value from the user for that field for each row.
         """
@@ -857,10 +717,7 @@ class CallbackUtil:
         if not records:
             raise SapioException("No records provided.")
         data_type: str = AliasUtil.to_singular_data_type_name(records)
-        if index_field is not None:
-            field_map_list: list[FieldMap] = self.__get_indexed_field_maps(records, index_field)
-        else:
-            field_map_list: list[FieldMap] = AliasUtil.to_field_map_list(records)
+        field_map_list: list[FieldMap] = AliasUtil.to_field_map_list(records)
 
         # Convert the group_by parameter to a field name.
         if group_by is not None:
@@ -886,20 +743,20 @@ class CallbackUtil:
         request = TableEntryDialogRequest(title, msg, temp_dt, field_map_list,
                                           record_image_data_list=image_data, group_by_field=group_by,
                                           width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-        response: list[FieldMap] = self.__send_dialog(request, self.callback.show_table_entry_dialog)
+        response: list[FieldMap] = self.__handle_dialog_request(request, self.callback.show_table_entry_dialog)
         return response
 
     # FR-47314: Create record form and table dialogs for updating or creating records.
     def set_record_table_dialog(self,
                                 title: str,
                                 msg: str,
-                                fields: Iterable[FieldValue] | DataTypeLayoutIdentifier,
-                                records: Iterable[SapioRecord],
+                                fields: list[FieldValue] | DataTypeLayoutIdentifier,
+                                records: list[SapioRecord],
                                 *,
                                 default_modifier: FieldModifier | None = None,
                                 field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                 group_by: FieldIdentifier | None = None,
-                                image_data: Iterable[bytes] | None = None):
+                                image_data: list[bytes] | None = None):
         """
         Create a table dialog where the user may input data into the fields of the table. The table is constructed from
         a given list of records of a singular type. After the user submits this dialog, the values that the user
@@ -930,35 +787,27 @@ class CallbackUtil:
         :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
             the image data list corresponds to the element at the same index in the records list.
         """
-        # Index the records with a field name that is the current time in milliseconds. This is done to avoid
-        # collisions with any existing field names.
-        index_field: str = f"_{TimeUtil.now_in_millis()}"
         results: list[FieldMap] = self.record_table_dialog(title, msg, fields, records,
                                                            default_modifier=default_modifier,
                                                            field_modifiers=field_modifiers,
-                                                           group_by=group_by, image_data=image_data,
-                                                           index_field=index_field)
+                                                           group_by=group_by, image_data=image_data)
         records_by_id: dict[int, SapioRecord] = self.rec_handler.map_by_id(records)
         for result in results:
-            index: int = result.pop(index_field)
-            records_by_id[index].set_field_values(result)
+            records_by_id[result["RecordId"]].set_field_values(result)
 
-    # FR-47690: Updated with blank result handling behavior.
     def create_record_table_dialog(self,
                                    title: str,
                                    msg: str,
-                                   fields: Iterable[FieldValue] | DataTypeLayoutIdentifier,
+                                   fields: list[FieldValue] | DataTypeLayoutIdentifier,
                                    wrapper_type: type[WrappedType] | str,
                                    count: int | tuple[int, int],
                                    *,
                                    default_modifier: FieldModifier | None = None,
                                    field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                    group_by: FieldIdentifier | None = None,
-                                   image_data: Iterable[bytes] | None = None,
-                                   require_input = None,
-                                   blank_result_handling: BlankResultHandling = BlankResultHandling.DEFAULT,
-                                   repeat_message: str | None = "Please provide a value to continue.",
-                                   cancel_message: str | None = "No value was provided. Cancelling dialog.") \
+                                   image_data: list[bytes] | None = None,
+                                   require_input: bool = False,
+                                   repeat_message: str | None = "Please provide a value to continue.") \
             -> list[WrappedType] | list[PyRecordModel]:
         """
         Create a table dialog where the user may input data into the fields of the table. The table is constructed from
@@ -992,18 +841,13 @@ class CallbackUtil:
             The user may remove this grouping if they want to.
         :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
             the image data list corresponds to the element at the same index in the records list.
-        :param require_input: DEPRECATED. Use blank_result_handling with a value of BlankResultHandling.REPEAT
-            instead.
-        :param blank_result_handling: Determine how to handle the result of a callback when the user provides a blank
-            result.
-        :param repeat_message: If blank_result_handling is REPEAT and a repeat_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
-        :param cancel_message: If blank_result_handling is CANCEL and a cancel_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
+        :param require_input: If true and the user is prompted to input the number of records to create, the request
+            will be re-sent if the user submits the dialog without making a selection.
+        :param repeat_message: If require_input is true and a repeat_message is provided, then that message appears
+            as toaster text if the record count dialog is repeated.
         :return: A list of the newly created records.
         """
-        count: int = self.__prompt_for_count(count, wrapper_type, require_input, blank_result_handling, repeat_message,
-                                             cancel_message)
+        count: int = self.__prompt_for_count(count, wrapper_type, require_input, repeat_message)
         if count <= 0:
             return []
         records: list[WrappedType] | list[PyRecordModel] = self.rec_handler.add_models(wrapper_type, count)
@@ -1016,15 +860,14 @@ class CallbackUtil:
     def record_adaptive_dialog(self,
                                title: str,
                                msg: str,
-                               fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
-                               records: Collection[SapioRecord],
+                               fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                               records: list[SapioRecord],
                                *,
                                default_modifier: FieldModifier | None = None,
                                field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                column_positions: dict[str, tuple[int, int]] | None = None,
                                group_by: FieldIdentifier | None = None,
-                               image_data: Iterable[bytes] | None = None,
-                               index_field: str | None = None) -> list[FieldMap]:
+                               image_data: list[bytes] | None = None) -> list[FieldMap]:
         """
         Create a dialog where the user may input data into the specified fields. The dialog is constructed from
         a given list of records of a singular type.
@@ -1060,12 +903,6 @@ class CallbackUtil:
         :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
             the image data list corresponds to the element at the same index in the records list. Only used if the
             adaptive dialog becomes a table.
-        :param index_field: If provided, the returned field maps will contain a field with this name that is equal to
-            the record ID of the record at the same index in the records list. This can be used to map the results
-            back to the original records. This is used instead of using a RecordId field, as the RecordId field has
-            special behavior in the system that can cause issues if the given records are uncommitted record models
-            with negative record IDs, meaning we don't want to have a RecordId field in the field maps provided to the
-            system. Only used if the adaptive dialog becomes a table.
         :return: A list of dictionaries mapping the data field names of the given field definitions to the response
             value from the user for that field for each row. Even if a form was displayed, the field values will still
             be returned in a list.
@@ -1074,23 +911,23 @@ class CallbackUtil:
         if not count:
             raise SapioException("No records provided.")
         if count == 1:
-            return [self.record_form_dialog(title, msg, fields, list(records)[0], column_positions,
+            return [self.record_form_dialog(title, msg, fields, records[0], column_positions,
                                             default_modifier=default_modifier, field_modifiers=field_modifiers)]
         return self.record_table_dialog(title, msg, fields, records,
                                         default_modifier=default_modifier, field_modifiers=field_modifiers,
-                                        group_by=group_by, image_data=image_data, index_field=index_field)
+                                        group_by=group_by, image_data=image_data)
 
     def set_record_adaptive_dialog(self,
                                    title: str,
                                    msg: str,
-                                   fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
-                                   records: Collection[SapioRecord],
+                                   fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                                   records: list[SapioRecord],
                                    *,
                                    default_modifier: FieldModifier | None = None,
                                    field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                    column_positions: dict[str, tuple[int, int]] | None = None,
                                    group_by: FieldIdentifier | None = None,
-                                   image_data: Iterable[bytes] | None = None) -> None:
+                                   image_data: list[bytes] | None = None) -> None:
         """
         Create a dialog where the user may input data into the fields of the dialog. The dialog is constructed from
         a given list of records of a singular type. After the user submits this dialog, the values that the user
@@ -1132,18 +969,17 @@ class CallbackUtil:
         if not count:
             raise SapioException("No records provided.")
         if count == 1:
-            self.set_record_form_dialog(title, msg, fields, list(records)[0], column_positions,
+            self.set_record_form_dialog(title, msg, fields, records[0], column_positions,
                                         default_modifier=default_modifier, field_modifiers=field_modifiers)
         else:
             self.set_record_table_dialog(title, msg, fields, records,
                                          default_modifier=default_modifier, field_modifiers=field_modifiers,
                                          group_by=group_by, image_data=image_data)
 
-    # FR-47690: Updated with blank result handling behavior.
     def create_record_adaptive_dialog(self,
                                       title: str,
                                       msg: str,
-                                      fields: Iterable[FieldValue] | DataTypeLayoutIdentifier,
+                                      fields: list[FieldValue] | DataTypeLayoutIdentifier,
                                       wrapper_type: type[WrappedType] | str,
                                       count: int | tuple[int, int],
                                       *,
@@ -1151,11 +987,9 @@ class CallbackUtil:
                                       field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                       column_positions: dict[str, tuple[int, int]] | None = None,
                                       group_by: FieldIdentifier | None = None,
-                                      image_data: Iterable[bytes] | None = None,
-                                      require_input = None,
-                                      blank_result_handling: BlankResultHandling = BlankResultHandling.DEFAULT,
-                                      repeat_message: str | None = "Please provide a value to continue.",
-                                      cancel_message: str | None = "No value was provided. Cancelling dialog.") \
+                                      image_data: list[bytes] | None = None,
+                                      require_input: bool = False,
+                                      repeat_message: str | None = "Please provide a value to continue.") \
             -> list[WrappedType]:
         """
         Create a dialog where the user may input data into the specified fields. The dialog is constructed from
@@ -1196,19 +1030,14 @@ class CallbackUtil:
         :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
             the image data list corresponds to the element at the same index in the records list. Only used if the
             adaptive dialog becomes a table.
-        :param require_input: DEPRECATED. Use blank_result_handling with a value of BlankResultHandling.REPEAT
-            instead.
-        :param blank_result_handling: Determine how to handle the result of a callback when the user provides a blank
-            result.
-        :param repeat_message: If blank_result_handling is REPEAT and a repeat_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
-        :param cancel_message: If blank_result_handling is CANCEL and a cancel_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
+        :param require_input: If true and the user is prompted to input the number of records to create, the request
+            will be re-sent if the user submits the dialog without making a selection.
+        :param repeat_message: If require_input is true and a repeat_message is provided, then that message appears
+            as toaster text if the record count dialog is repeated.
         :return: A list of the newly created records. Even if a form was displayed, the created record will still be
             returned in a list.
         """
-        count: int = self.__prompt_for_count(count, wrapper_type, require_input, blank_result_handling, repeat_message,
-                                             cancel_message)
+        count: int = self.__prompt_for_count(count, wrapper_type, require_input, repeat_message)
         if count <= 0:
             return []
         if count == 1:
@@ -1218,20 +1047,17 @@ class CallbackUtil:
                                                default_modifier=default_modifier, field_modifiers=field_modifiers,
                                                group_by=group_by, image_data=image_data)
 
-    # FR-47690: Add group_by and image_data parameters.
     def multi_type_table_dialog(self,
                                 title: str,
                                 msg: str,
-                                fields: Iterable[tuple[DataTypeIdentifier, FieldIdentifier] | AbstractVeloxFieldDefinition],
-                                row_contents: Iterable[Iterable[SapioRecord | FieldMap]],
+                                fields: list[tuple[DataTypeIdentifier, FieldIdentifier] | AbstractVeloxFieldDefinition],
+                                row_contents: list[list[SapioRecord | FieldMap]],
                                 *,
                                 default_modifier: FieldModifier | None = None,
                                 field_modifiers: dict[FieldIdentifier, FieldModifier] | None = None,
                                 data_type: DataTypeIdentifier = "Default",
                                 display_name: str | None = None,
-                                plural_display_name: str | None = None,
-                                group_by: FieldIdentifier | None = None,
-                                image_data: list[bytes] | None = None) -> list[FieldMap]:
+                                plural_display_name: str | None = None) -> list[FieldMap]:
         """
         Create a table dialog where the user may input data into the fields of the table. The table is constructed from
         a given list of records of multiple data types or field maps. Provided field names must match with field names
@@ -1285,10 +1111,6 @@ class CallbackUtil:
             name.
         :param plural_display_name: The plural display name for the temporary data type. If not provided, defaults to
             the display name + "s".
-        :param group_by: If provided, the created table dialog will be grouped by the field with this name by default.
-            The user may remove this grouping if they want to.
-        :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
-            the image data list corresponds to the element at the same index in the values list.
         :return: A list of dictionaries mapping the data field names of the given field definitions to the response
             value from the user for that field for each row.
         """
@@ -1353,49 +1175,31 @@ class CallbackUtil:
             field_names.add(name)
 
         # Get the values for each row.
-        # FR-47690: Updated this for loop to better match the Java implementation.
         values: list[dict[str, FieldValue]] = []
         for row in row_contents:
             # The final values for this row:
             row_values: dict[str, FieldValue] = {}
 
-            # Map the records for this row by their data type. If a field map is provided, save it separately to
-            # the temp_values dict.
-            row_records: dict[str, SapioRecord] = {}
-            temp_values: FieldMap = {}
+            # Map the records for this row by their data type. If a field map is provided, its data type is Default.
+            row_records: dict[str, SapioRecord | FieldMap] = {}
             for rec in row:
                 # Toss out null elements.
                 if rec is None:
                     continue
                 # Map records to their data type name. Map field maps to Default.
-                dt: str = "Default" if isinstance(rec, dict) else AliasUtil.to_data_type_name(rec)
-                if dt == "Default":
-                    temp_values.update(rec)
-                else:
-                    # Warn if the same data type name appears more than once.
-                    if dt in row_records:
-                        raise SapioException(f"The data type \"{dt}\" appears more than once in the given row contents.")
-                    row_records[dt] = rec
+                dt: str = "Default" if isinstance(rec, dict) else AliasUtil.to_data_type_names(rec)
+                # Warn if the same data type name appears more than once.
+                if dt in row_records:
+                    raise SapioException(f"The data type \"{dt}\" appears more than once in the given row contents.")
+                row_records[dt] = rec
 
             # Get the field values from the above records.
             for field in final_fields:
-                value: Any | None = None
-
                 # Find the object that corresponds to this field given its data type name.
-                dt: str = field.data_type_name
-                fd: str = field.data_field_name
-                if dt == "Default":
-                    # If the field map is provided, get the value from it.
-                    # FR-47690: If a value is not provided, then use the default value of the field definition.
-                    if fd in temp_values:
-                        value = temp_values.get(fd)
-                    else:
-                        value = field.default_value
-                elif dt in row_records:
-                    record: SapioRecord = row_records[dt]
-                    # If the record is not null, get the value from the record.
-                    if record is not None:
-                        value = record.get_field_value(fd)
+                record: SapioRecord | FieldMap | None = row_records.get(field.data_type_name)
+                # This could be either a record, a field map, or null. Convert any records to field maps.
+                if not isinstance(record, dict) and record is not None:
+                    record: FieldMap | None = AliasUtil.to_field_map(record)
 
                 # Find out if this field had its data type prepended to it. If this is the case, then we need to find
                 # the true data field name before retrieving the value from the field map.
@@ -1404,22 +1208,16 @@ class CallbackUtil:
                     name = name.split(".")[1]
 
                 # Set the value for this particular field.
-                row_values[name] = value
+                row_values[field.data_field_name] = record.get(name) if record else None
             values.append(row_values)
 
         # Build a temporary data type for the request.
         temp_dt = self.__temp_dt_from_field_defs(data_type, display_name, plural_display_name, final_fields, None)
-        temp_dt.record_image_assignable = bool(image_data)
-
-        # Convert the group_by parameter to a field name.
-        if group_by is not None:
-            group_by: str = AliasUtil.to_data_field_name(group_by)
 
         # Send the request to the user.
         request = TableEntryDialogRequest(title, msg, temp_dt, values,
-                                          record_image_data_list=image_data, group_by_field=group_by,
                                           width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-        response: list[FieldMap] = self.__send_dialog(request, self.callback.show_table_entry_dialog)
+        response: list[FieldMap] = self.__handle_dialog_request(request, self.callback.show_table_entry_dialog)
         return response
 
     def record_view_dialog(self,
@@ -1428,7 +1226,7 @@ class CallbackUtil:
                            layout: DataTypeLayoutIdentifier = None,
                            minimized: bool = False,
                            access_level: FormAccessLevel | None = None,
-                           plugin_path_list: Iterable[str] | None = None) -> None:
+                           plugin_path_list: list[str] | None = None) -> None:
         """
         Create an IDV dialog for the given record. This IDV may use an existing layout already defined in the system,
         and can be created to allow the user to edit the field in the IDV, or to be read-only for the user to review.
@@ -1456,30 +1254,26 @@ class CallbackUtil:
         # Send the request to the user.
         request = DataRecordDialogRequest(title, record, layout, minimized, access_level, plugin_path_list,
                                           width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
-        response: bool = self.__send_dialog(request, self.callback.data_record_form_view_dialog)
+        response: bool = self.__handle_dialog_request(request, self.callback.data_record_form_view_dialog)
         # The __handle_dialog_request function only throws a cancelled exception if the response is None, but in
         # this case we also want to throw if the response is False.
         if not response:
             raise SapioUserCancelledException()
 
     # CR-47326: Allow the selection dialog functions to preselect rows/records in the table.
-    # FR-47690: Added shortcut_single_option parameter. Updated with blank result handling behavior.
     def selection_dialog(self,
                          msg: str,
-                         fields: Iterable[AbstractVeloxFieldDefinition],
-                         values: Iterable[FieldMap],
+                         fields: list[AbstractVeloxFieldDefinition],
+                         values: list[FieldMap],
                          multi_select: bool = True,
-                         preselected_rows: Iterable[FieldMap | RecordIdentifier] | None = None,
+                         preselected_rows: list[FieldMap | RecordIdentifier] | None = None,
                          *,
                          data_type: DataTypeIdentifier = "Default",
                          display_name: str | None = None,
                          plural_display_name: str | None = None,
-                         image_data: Iterable[bytes] | None = None,
-                         shortcut_single_option: bool = True,
-                         require_selection = None,
-                         blank_result_handling: BlankResultHandling = BlankResultHandling.DEFAULT,
-                         repeat_message: str | None = "Please provide a selection to continue.",
-                         cancel_message: str | None = "No selection was made. Cancelling dialog.") -> list[FieldMap]:
+                         image_data: list[bytes] | None = None,
+                         require_selection: bool = False,
+                         repeat_message: str | None = "Please provide a selection to continue.") -> list[FieldMap]:
         """
         Create a selection dialog for a list of field maps for the user to choose from. Requires that the caller
         provide the definitions of every field in the table.
@@ -1502,23 +1296,14 @@ class CallbackUtil:
             the display name + "s".
         :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
             the image data list corresponds to the element at the same index in the values list.
-        :param shortcut_single_option: If true, then if the list contains only one option, the dialog will not be shown
-            and the single option will be returned immediately.
-        :param require_selection: DEPRECATED. Use blank_result_handling with a value of BlankResultHandling.REPEAT
-            instead.
-        :param blank_result_handling: Determine how to handle the result of a callback when the user provides a blank
-            result.
-        :param repeat_message: If blank_result_handling is REPEAT and a repeat_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
-        :param cancel_message: If blank_result_handling is CANCEL and a cancel_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
+        :param require_selection: If true, the request will be re-sent if the user submits the dialog without making
+            a selection.
+        :param repeat_message: If require_selection is true and a repeat_message is provided, then that message appears
+            as toaster text if the dialog is repeated.
         :return: A list of field maps corresponding to the chosen input field maps.
         """
         if not values:
             raise SapioException("No values provided.")
-        values = list(values)
-        if len(values) == 1 and shortcut_single_option:
-            return [values[0]]
 
         if preselected_rows:
             # Confirm that the provided field maps are validly configured to allow the use of preselected rows.
@@ -1544,7 +1329,6 @@ class CallbackUtil:
 
             # Add a RecordId definition to the fields if one is not already present. This is necessary for the
             # pre-selected records parameter to function.
-            fields = list(fields)
             if "RecordId" not in [x.data_field_name for x in fields]:
                 builder = FieldBuilder(data_type)
                 fields.append(builder.long_field("RecordId", abstract_info=AnyFieldInfo(visible=False)))
@@ -1554,31 +1338,27 @@ class CallbackUtil:
         temp_dt.record_image_assignable = bool(image_data)
 
         # Send the request to the user.
-        request = TempTableSelectionRequest(temp_dt, msg, list(values), image_data, preselected_rows, multi_select)
-
-        # Reverse compatibility: If require_selection is true and blank_result_handling is not set, then
-        # set blank_result_handling to REPEAT.
-        if require_selection is True and blank_result_handling == BlankResultHandling.DEFAULT:
-            blank_result_handling = BlankResultHandling.REPEAT
-        def not_blank_func(r: list[FieldMap]) -> bool:
-            return bool(r)
-        return self.__send_dialog_blank_results(request, self.callback.show_temp_table_selection_dialog, not_blank_func,
-                                                blank_result_handling, repeat_message, cancel_message)
-
-    # FR-47690: Added shortcut_single_option parameter. Updated with blank result handling behavior.
+        request = TempTableSelectionRequest(temp_dt, msg, values, image_data, preselected_rows, multi_select)
+        # If require_selection is true, repeat the request if the user didn't make a selection.
+        while True:
+            response: list[FieldMap] = self.__handle_dialog_request(request,
+                                                                    self.callback.show_temp_table_selection_dialog)
+            if not require_selection or response:
+                break
+            if repeat_message:
+                self.toaster_popup(repeat_message, popup_type=PopupType.Warning)
+        return response
+
     def record_selection_dialog(self,
                                 msg: str,
-                                fields: Iterable[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
-                                records: Iterable[SapioRecord],
+                                fields: list[FieldIdentifier | FieldFilterCriteria] | DataTypeLayoutIdentifier,
+                                records: list[SapioRecord],
                                 multi_select: bool = True,
-                                preselected_records: Iterable[RecordIdentifier] | None = None,
+                                preselected_records: list[RecordIdentifier] | None = None,
                                 *,
-                                image_data: Iterable[bytes] | None = None,
-                                shortcut_single_option: bool = True,
-                                require_selection = None,
-                                blank_result_handling: BlankResultHandling = BlankResultHandling.DEFAULT,
-                                repeat_message: str | None = "Please provide a selection to continue.",
-                                cancel_message: str | None = "No selection was made. Cancelling dialog.") \
+                                image_data: list[bytes] | None = None,
+                                require_selection: bool = False,
+                                repeat_message: str | None = "Please provide a selection to continue.") \
             -> list[SapioRecord]:
         """
         Create a record selection dialog for a list of records for the user to choose from. Provided field names must
@@ -1600,24 +1380,15 @@ class CallbackUtil:
             record IDs are provided, the dialog will automatically allow multi-selection of records.
         :param image_data: The bytes to the images that should be displayed in the rows of the table. Each element in
             the image data list corresponds to the element at the same index in the records list.
-        :param shortcut_single_option: If true, then if the list contains only one option, the dialog will not be shown
-            and the single option will be returned immediately.
-        :param require_selection: DEPRECATED. Use blank_result_handling with a value of BlankResultHandling.REPEAT
-            instead.
-        :param blank_result_handling: Determine how to handle the result of a callback when the user provides a blank
-            result.
-        :param repeat_message: If blank_result_handling is REPEAT and a repeat_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
-        :param cancel_message: If blank_result_handling is CANCEL and a cancel_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
+        :param require_selection: If true, the request will be re-sent if the user submits the dialog without making
+            a selection.
+        :param repeat_message: If require_selection is true and a repeat_message is provided, then that message appears
+            as toaster text if the dialog is repeated.
         :return: A list of the selected records.
         """
         # Get the data type name and field values from the provided records.
         if not records:
             raise SapioException("No records provided.")
-        records = list(records)
-        if len(records) == 1 and shortcut_single_option:
-            return [records[0]]
         data_type: str = AliasUtil.to_singular_data_type_name(records)
         field_map_list: list[FieldMap] = AliasUtil.to_field_map_list(records, include_record_id=True)
 
@@ -1644,17 +1415,14 @@ class CallbackUtil:
 
         # Send the request to the user.
         request = TempTableSelectionRequest(temp_dt, msg, field_map_list, image_data, preselected_records, multi_select)
-
-        # Reverse compatibility: If require_selection is true and blank_result_handling is not set, then
-        # set blank_result_handling to REPEAT.
-        if require_selection is True and blank_result_handling == BlankResultHandling.DEFAULT:
-            blank_result_handling = BlankResultHandling.REPEAT
-        def not_blank_func(r: list[FieldMap]) -> bool:
-            return bool(r)
-        response: list[FieldMap] = self.__send_dialog_blank_results(request,
-                                                                    self.callback.show_temp_table_selection_dialog,
-                                                                    not_blank_func, blank_result_handling,
-                                                                    repeat_message, cancel_message)
+        # If require_selection is true, repeat the request if the user didn't make a selection.
+        while True:
+            response: list[FieldMap] = self.__handle_dialog_request(request,
+                                                                    self.callback.show_temp_table_selection_dialog)
+            if not require_selection or response:
+                break
+            if repeat_message:
+                self.toaster_popup(repeat_message, popup_type=PopupType.Warning)
 
         # Map the field maps in the response back to the record they come from, returning the chosen record instead of
         # the chosen field map.
@@ -1665,25 +1433,22 @@ class CallbackUtil:
         return ret_list
 
     # CR-47377: Add allow_creation and default_creation_number to cover new parameters of this request type from 24.12.
-    # FR-47690: Updated with blank result handling behavior.
     def input_selection_dialog(self,
                                wrapper_type: type[WrappedType] | str,
                                msg: str,
                                multi_select: bool = True,
                                only_key_fields: bool = False,
-                               search_types: Iterable[SearchType] | None = None,
+                               search_types: list[SearchType] | None = None,
                                scan_criteria: ScanToSelectCriteria | None = None,
                                custom_search: CustomReport | CustomReportCriteria | str | None = None,
-                               preselected_records: Iterable[RecordIdentifier] | None = None,
-                               record_blacklist: Iterable[RecordIdentifier] | None = None,
-                               record_whitelist: Iterable[RecordIdentifier] | None = None,
+                               preselected_records: list[RecordIdentifier] | None = None,
+                               record_blacklist: list[RecordIdentifier] | None = None,
+                               record_whitelist: list[RecordIdentifier] | None = None,
                                allow_creation: bool = False,
                                default_creation_number: int = 1,
                                *,
-                               require_selection = None,
-                               blank_result_handling: BlankResultHandling = BlankResultHandling.DEFAULT,
-                               repeat_message: str | None = "Please provide a selection to continue.",
-                               cancel_message: str | None = "No selection was made. Cancelling dialog.") \
+                               require_selection: bool = False,
+                               repeat_message: str | None = "Please provide a selection to continue.") \
             -> list[WrappedType] | list[PyRecordModel]:
         """
         Display a table of records that exist in the system matching the given data type and filter criteria and have
@@ -1725,14 +1490,10 @@ class CallbackUtil:
             than 1, then multi-selection must be true. The data type definition of the records being created must have
             "Prompt for Number to Add" set to true in order to allow the user to select how many records to create, as
             otherwise user will only ever be able to create one record at a time.
-        :param require_selection: DEPRECATED. Use blank_result_handling with a value of BlankResultHandling.REPEAT
-            instead.
-        :param blank_result_handling: Determine how to handle the result of a callback when the user provides a blank
-            result.
-        :param repeat_message: If blank_result_handling is REPEAT and a repeat_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
-        :param cancel_message: If blank_result_handling is CANCEL and a cancel_message is provided, then that message
-            appears as toaster text when the user provides a blank result.
+        :param require_selection: If true, the request will be re-sent if the user submits the dialog without making
+            a selection.
+        :param repeat_message: If require_selection is true and a repeat_message is provided, then that message appears
+            as toaster text if the dialog is repeated.
         :return: A list of the records selected by the user in the dialog, wrapped as record models using the provided
             wrapper.
         """
@@ -1758,25 +1519,23 @@ class CallbackUtil:
         request = InputSelectionRequest(data_type, msg, search_types, only_key_fields, record_blacklist,
                                         record_whitelist, preselected_records, custom_search, scan_criteria,
                                         multi_select, allow_creation, default_creation_number)
+        # If require_selection is true, repeat the request if the user didn't make a selection.
+        while True:
+            response: list[DataRecord] = self.__handle_dialog_request(request,
+                                                                      self.callback.show_input_selection_dialog)
+            if not require_selection or response:
+                break
+            if repeat_message:
+                self.toaster_popup(repeat_message, popup_type=PopupType.Warning)
+        return self.rec_handler.wrap_models(response, wrapper_type)
 
-        # Reverse compatibility: If require_selection is true and blank_result_handling is not set, then
-        # set blank_result_handling to REPEAT.
-        if require_selection is True and blank_result_handling == BlankResultHandling.DEFAULT:
-            blank_result_handling = BlankResultHandling.REPEAT
-        def not_blank_func(r: list[DataRecord]) -> bool:
-            return bool(r)
-        return self.__send_dialog_blank_results(request, self.callback.show_input_selection_dialog, not_blank_func,
-                                                blank_result_handling, repeat_message, cancel_message)
-
-    # FR-47690: Deprecated the require_authentication parameter.
-    # noinspection PyUnusedLocal
     def esign_dialog(self,
                      title: str,
                      msg: str,
                      show_comment: bool = True,
-                     additional_fields: Iterable[AbstractVeloxFieldDefinition] | None = None,
+                     additional_fields: list[AbstractVeloxFieldDefinition] | None = None,
                      *,
-                     require_authentication = None) -> ESigningResponsePojo:
+                     require_authentication: bool = False) -> ESigningResponsePojo:
         """
         Create an e-sign dialog for the user to interact with.
 
@@ -1786,7 +1545,8 @@ class CallbackUtil:
             user is required to provide an action.
         :param additional_fields: Field definitions for additional fields to display in the dialog, for if there is
             other information you wish to gather from the user alongside the e-sign.
-        :param require_authentication: DEPRECATED. Authentication is always required when using this function.
+        :param require_authentication: If true, the request will be re-sent if the user submits the dialog with invalid
+            credentials.
         :return: An e-sign response object containing information about the e-sign attempt.
         """
         # Construct a temporary data type if any additional fields are provided.
@@ -1800,9 +1560,10 @@ class CallbackUtil:
         # Send the request to the user.
         request = ESigningRequestPojo(title, msg, show_comment, temp_dt,
                                       width_in_pixels=self.width_pixels, width_percentage=self.width_percent)
+        # If require_authentication is true, repeat the request if the user didn't provide valid credentials.
         while True:
-            response: ESigningResponsePojo = self.__send_dialog(request, self.callback.show_esign_dialog)
-            if response.authenticated:
+            response: ESigningResponsePojo = self.__handle_dialog_request(request, self.callback.show_esign_dialog)
+            if not require_authentication or response.authenticated:
                 break
             # This matches the OOB behavior.
             self.toaster_popup("Incorrect username/password", popup_type=PopupType.Error)
@@ -1811,7 +1572,7 @@ class CallbackUtil:
                                    popup_type=PopupType.Error)
         return response
 
-    def request_file(self, title: str, exts: Iterable[str] | None = None,
+    def request_file(self, title: str, exts: list[str] | None = None,
                      show_image_editor: bool = False, show_camera_button: bool = False) -> tuple[str, bytes]:
         """
         Request a single file from the user.
@@ -1838,13 +1599,13 @@ class CallbackUtil:
 
             # Send the request to the user.
             request = FilePromptRequest(title, show_image_editor, ",".join(exts), show_camera_button)
-            file_path: str = self.__send_dialog(request, self.callback.show_file_dialog, data_sink=do_consume)
+            file_path: str = self.__handle_dialog_request(request, self.callback.show_file_dialog, data_sink=do_consume)
 
         # Verify that each of the file given matches the expected extension(s).
         self.__verify_file(file_path, sink.data, exts)
         return file_path, sink.data
 
-    def request_files(self, title: str, exts: Iterable[str] | None = None,
+    def request_files(self, title: str, exts: list[str] | None = None,
                       show_image_editor: bool = False, show_camera_button: bool = False) -> dict[str, bytes]:
         """
         Request multiple files from the user.
@@ -1863,7 +1624,7 @@ class CallbackUtil:
 
         # Send the request to the user.
         request = MultiFilePromptRequest(title, show_image_editor, ",".join(exts), show_camera_button)
-        file_paths: list[str] = self.__send_dialog(request, self.callback.show_multi_file_dialog)
+        file_paths: list[str] = self.__handle_dialog_request(request, self.callback.show_multi_file_dialog)
 
         # Verify that each of the files given match the expected extension(s).
         ret_dict: dict[str, bytes] = {}
@@ -1876,7 +1637,7 @@ class CallbackUtil:
         return ret_dict
 
     @staticmethod
-    def __verify_file(file_path: str, file_bytes: bytes, allowed_extensions: Iterable[str]) -> None:
+    def __verify_file(file_path: str, file_bytes: bytes, allowed_extensions: list[str]) -> None:
         """
         Verify that the provided file was read (i.e. the file path and file bytes aren't None or empty) and that it
         has the correct file extension. Raises a user error exception if something about the file is incorrect.
@@ -1887,11 +1648,10 @@ class CallbackUtil:
         """
         if file_path is None or len(file_path) == 0 or file_bytes is None or len(file_bytes) == 0:
             raise SapioUserErrorException("Empty file provided or file unable to be read.")
-        if allowed_extensions:
+        if len(allowed_extensions) != 0:
             matches: bool = False
             for ext in allowed_extensions:
-                # FR-47690: Changed to a case-insensitive match.
-                if file_path.casefold().endswith("." + ext.lstrip(".").casefold()):
+                if file_path.endswith("." + ext.lstrip(".")):
                     matches = True
                     break
             if matches is False:
@@ -1905,8 +1665,8 @@ class CallbackUtil:
         :param file_name: The name of the file.
         :param file_data: The data of the file, provided as either a string or as a bytes array.
         """
-        with io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data) as data:
-            self.callback.send_file(file_name, False, data)
+        data = io.BytesIO(file_data.encode() if isinstance(file_data, str) else file_data)
+        self.callback.send_file(file_name, False, data)
 
     def write_zip_file(self, zip_name: str, files: dict[str, str | bytes]) -> None:
         """
@@ -1915,38 +1675,16 @@ class CallbackUtil:
         :param zip_name: The name of the zip file.
         :param files: A dictionary of the files to add to the zip file.
         """
-        self.write_file(zip_name, FileUtil.zip_files(files))
-
-    @staticmethod
-    def __get_indexed_field_maps(records: Iterable[SapioRecord], index_field: str) -> list[FieldMap]:
-        """
-        For dialogs that accept multiple records, we may want to be able to match the returned results back to the
-        records that they're for. In this case, we need to add an index to each record so that we can match them back
-        to the original records. We can't use the RecordId field, as new record models have negative record IDs that
-        cause the callback dialogs to bug out if the RecordId field is present and negative.
-
-        :param records: The records to return indexed field maps of.
-        :param index_field: The name of the field to use as the index. Make sure that this field doesn't exist on the
-            records, as then it will overwrite the existing value.
-        :return: A list of field maps for the records, with an index field added to each. The value of the index on
-            each field map is the record's record ID (even if it's a record model with a negative ID).
-        """
-        ret_val: list[FieldMap] = []
-        for record in records:
-            field_map: FieldMap = AliasUtil.to_field_map(record)
-            field_map[index_field] = AliasUtil.to_record_id(record)
-            ret_val.append(field_map)
-        return ret_val
+        data = io.BytesIO(FileUtil.zip_files(files))
+        self.callback.send_file(zip_name, False, data)
 
     @staticmethod
     def __temp_dt_from_field_defs(data_type: DataTypeIdentifier, display_name: str | None,
-                                  plural_display_name: str | None, fields: Iterable[AbstractVeloxFieldDefinition],
+                                  plural_display_name: str | None, fields: list[AbstractVeloxFieldDefinition],
                                   column_positions: dict[str, tuple[int, int]] | None) -> TemporaryDataType:
         """
         Construct a Temporary Data Type definition from a provided list of field definitions for use in a callback.
         """
-        if not fields:
-            raise SapioException("No fields provided to create a temporary data type.")
         # Get the data type name as a string from the parameters, and set the display name and plural display name if
         # they haven't been set.
         data_type: str = AliasUtil.to_data_type_name(data_type)
@@ -1976,7 +1714,7 @@ class CallbackUtil:
             builder.add_field(field_def, column, span)
         return builder.get_temporary_data_type()
 
-    def __temp_dt_from_field_names(self, data_type: str, fields: Iterable[FieldIdentifier | FieldFilterCriteria],
+    def __temp_dt_from_field_names(self, data_type: str, fields: list[FieldIdentifier | FieldFilterCriteria],
                                    column_positions: dict[str, tuple[int, int]] | None,
                                    default_modifier: FieldModifier, field_modifiers: dict[str, FieldModifier]) \
             -> TemporaryDataType:
@@ -1993,7 +1731,6 @@ class CallbackUtil:
 
         # Determine if any FieldFilterCriteria were provided. If so, remove them from the fields list so that it
         # contains only field identifiers.
-        fields = list(fields)
         filter_criteria: list[FieldFilterCriteria] = [x for x in fields if isinstance(x, FieldFilterCriteria)]
         for criteria in filter_criteria:
             fields.remove(criteria)
@@ -2066,10 +1803,8 @@ class CallbackUtil:
             temp_dt.set_field_definition(modifier.modify_field(field_def))
         return temp_dt
 
-    # FR-47690: Updated with blank result handling behavior.
     def __prompt_for_count(self, count: tuple[int, int] | int, wrapper_type: type[WrappedType] | str,
-                           require_input: bool, blank_result_handling: BlankResultHandling, repeat_message: str,
-                           cancel_message: str) -> int:
+                           require_input: bool, repeat_message: str) -> int:
         """
         Given a count value, if it is a tuple representing an allowable range of values for a number of records to
         create, prompt the user to input the exact count to use. If the count is already a single integer, simply
@@ -2082,14 +1817,8 @@ class CallbackUtil:
                 plural: str = self.dt_cache.get_plural_display_name(AliasUtil.to_data_type_name(wrapper_type))
             min_val, max_val = count
             msg: str = f"How many {plural} should be created? ({min_val} to {max_val})"
-            count_field: VeloxIntegerFieldDefinition = FieldBuilder().int_field("Count", min_value=min_val,
-                                                                                max_value=max_val,
-                                                                                default_value=min_val)
-            count: int = self.input_dialog(f"Create {plural}", msg, count_field,
-                                           require_input=require_input, blank_result_handling=blank_result_handling,
-                                           repeat_message=repeat_message, cancel_message=cancel_message)
-            if count is None:
-                count = 0
+            count: int = self.integer_input_dialog(f"Create {plural}", msg, "Count", min_val, min_val, max_val,
+                                                   require_input=require_input, repeat_message=repeat_message)
         return count
 
     def __to_layout(self, data_type: str, layout: DataTypeLayoutIdentifier) -> DataTypeLayout | None:
@@ -2154,18 +1883,19 @@ class CallbackUtil:
                 raise SapioException(f"No field of name \"{field_name}\" in field definitions of type \"{data_type}\"")
         return field_def
 
-    def __handle_timeout(self, func: Callable, request: Any, **kwargs) -> Any:
+    def __handle_dialog_request(self, request: Any, func: Callable, **kwargs) -> Any:
         """
         Send a client callback request to the user that creates a dialog.
 
         This function handles updating the user object's request timeout to match the request timeout of this
         CallbackUtil for the duration of the dialog.
         If the dialog times out then a SapioDialogTimeoutException is thrown.
+        If the user cancels the dialog then a SapioUserCancelledException is thrown.
 
         :param request: The client callback request to send to the user.
         :param func: The ClientCallback function to call with the given request as input.
         :param kwargs: Additional keywords for the provided function call.
-        :return: The response from the client callback.
+        :return: The response from the client callback, if one was received.
         """
         try:
             self.user.timeout_seconds = self.timeout_seconds
@@ -2174,73 +1904,10 @@ class CallbackUtil:
             raise SapioDialogTimeoutException()
         finally:
             self.user.timeout_seconds = self._original_timeout
-        return response
-
-    def __send_dialog(self, request: Any, func: Callable, **kwargs) -> Any:
-        """
-        Send a client callback request to the user that creates a dialog.
-
-        This function handles updating the user object's request timeout to match the request timeout of this
-        CallbackUtil for the duration of the dialog.
-        If the dialog times out then a SapioDialogTimeoutException is thrown.
-        If the user cancels the dialog then a SapioUserCancelledException is thrown.
-
-        :param request: The client callback request to send to the user.
-        :param func: The ClientCallback function to call with the given request as input.
-        :param kwargs: Additional keywords for the provided function call.
-        :return: The response from the client callback, if one was received.
-        """
-        response: Any | None = self.__handle_timeout(func, request, **kwargs)
         if response is None:
             raise SapioUserCancelledException()
         return response
 
-    def __send_dialog_blank_results(self, request: Any, func: Callable, not_blank_func: Callable,
-                                    handling: BlankResultHandling,
-                                    repeat_message: str | None, cancel_message: str | None, **kwargs):
-        """
-        Send a client callback request to the user that creates a dialog.
-
-        This function handles updating the user object's request timeout to match the request timeout of this
-        CallbackUtil for the duration of the dialog.
-        If the dialog times out then a SapioDialogTimeoutException is thrown.
-        If the user cancels the dialog then a SapioUserCancelledException is thrown.
-        If the user provides a blank result, then the handling is used to determine what to do with that result.
-
-        :param request: The client callback request to send to the user.
-        :param func: The ClientCallback function to call with the given request as input.
-        :param not_blank_func: The function to determine whether the provided result is blank or not.
-        :param handling: The handling to use for blank results.
-        :param repeat_message: If handling is REPEAT and a repeat_message is provided, then that message appears as
-            toaster text when the user provides a blank result.
-        :param cancel_message: If handling is CANCEL and a cancel_message is provided, then that message appears as
-            toaster text when the user provides a blank result.
-        :param kwargs: Additional keywords for the provided function call.
-        :return: The response from the client callback, if one was received.
-        """
-        if handling == BlankResultHandling.DEFAULT or handling is None:
-            handling = self._default_blank_result_handling
-        while True:
-            response: Any | None = self.__handle_timeout(func, request, **kwargs)
-            if response is None:
-                raise SapioUserCancelledException()
-            if not_blank_func(response):
-                return response
-            match handling:
-                case BlankResultHandling.CANCEL:
-                    # If the user provided no selection, throw an exception.
-                    if cancel_message:
-                        self.toaster_popup(cancel_message, popup_type=PopupType.Warning)
-                    raise SapioUserCancelledException()
-                case BlankResultHandling.REPEAT:
-                    # If the user provided no selection, repeat the dialog.
-                    # If a repeatMessage is provided, display it as a toaster popup.
-                    if repeat_message:
-                        self.toaster_popup(repeat_message, popup_type=PopupType.Warning)
-                case BlankResultHandling.RETURN:
-                    # If the user provided no selection, return the blank result.
-                    return response
-
 
 class FieldModifier:
     """
@@ -2316,15 +1983,15 @@ class FieldFilterCriteria:
     key_field: bool | None
     identifier: bool | None
     system_field: bool | None
-    field_types: Container[FieldType] | None
-    not_field_types: Container[FieldType] | None
+    field_types: list[FieldType] | None
+    not_field_types: list[FieldType] | None
     matches_tag: str | None
     contains_tag: str | None
     regex_tag: str | re.Pattern[str] | None
 
     def __init__(self, *, required: bool | None = None, editable: bool | None = None, key_field: bool | None = None,
                  identifier: bool | None = None, system_field: bool | None = None,
-                 field_types: Container[FieldType] | None = None, not_field_types: Container[FieldType] | None = None,
+                 field_types: list[FieldType] | None = None, not_field_types: list[FieldType] | None = None,
                  matches_tag: str | None = None, contains_tag: str | None = None,
                  regex_tag: str | re.Pattern[str] | None = None):
         """