// For Library Version: 1.136.16

declare namespace sap {
  /**
   * Root namespace for all the libraries related to SAP Fiori elements.
   */
  namespace fe {
    /**
     * Library providing the core functionality of the runtime for SAP Fiori elements for OData V4.
     */
    namespace core {
      /**
       * Collection of controller extensions used internally in SAP Fiori elements exposing a method that you
       * can override to allow more flexibility.
       */
      namespace controllerextensions {
        namespace MessageHandler {
          /**
           * Defines the message detail relevant for the MessageButton building block to display a popover.
           */
          type MessageDetail = {};
        }

        namespace ViewState {
          /**
           * Definition of a navigation parameter
           */
          type NavigationParameter = {
            /**
             * The actual navigation type.
             */
            navigationType: string;
            /**
             * Defines whether the standard variant must be used in variant management
             */
            requiresStandardVariant: boolean;
            /**
             * The selectionVariant from the navigation.
             */
            selectionVariant: sap.fe.navigation.SelectionVariant;
            /**
             * The selectionVariant defaults from the navigation
             */
            selectionVariantDefaults: sap.fe.navigation.SelectionVariant;
          };
        }

        /**
         * A base implementation for controller extension used internally in sap.fe for central functionalities.
         *
         * @since 1.118.0
         */
        class BaseControllerExtension extends sap.ui.core.mvc
          .ControllerExtension {}
        /**
         * A controller extension offering hooks into the edit flow of the application
         *
         * @since 1.90.0
         */
        class EditFlow extends sap.fe.core.controllerextensions
          .BaseControllerExtension {
          /**
           * Submit the current set of changes and navigate back.
           *
           * @since 1.90.0
           *
           * @returns Promise resolves once the changes have been saved
           */
          applyDocument(
            /**
             * Context of the document
             */
            oContext: sap.ui.model.odata.v4.Context
          ): Promise<void>;
          /**
           * Discard the editable document.
           *
           * @since 1.90.0
           *
           * @returns Promise resolves once editable document has been discarded
           */
          cancelDocument(
            /**
             * Context of the editable document
             */
            oContext: sap.ui.model.odata.v4.Context,
            /**
             * Can contain the following attributes:
             */
            mParameters: {
              /**
               * This is the control used to open the discard popover
               */
              control?: sap.m.Button;
              /**
               * Optional, supresses the discard popover and allows custom handling
               */
              skipDiscardPopover?: boolean;
            }
          ): Promise<sap.ui.model.odata.v4.Context | undefined>;
          /**
           * Creates a new document.
           *
           * @since 1.90.0
           *
           * @returns Promise resolves once the object has been created
           */
          createDocument(
            /**
             * ODataListBinding object or the binding path or a table building block for a temporary list binding
             */
            source: /* was: sap.fe.macros.Table */
              | any
              | sap.ui.model.odata.v4.ODataListBinding
              | string,
            /**
             * Contains the following attributes:
             */
            mInParameters: {
              /**
               * Specifies if the new entry should be created at the top or bottom of a table in case of creationMode
               * 'Inline'
               */
              createAtEnd?: boolean;
              /**
               * Defines the list of properties that are displayed in the creation dialog when the creation mode is set
               * to 'CreationDialog'.
               * The value is a comma-separated list of property names
               */
              creationDialogFields?: string[];
              /**
               * The creation mode using one of the following:
               *
               * NewPage - the created document is shown in a new page, depending on whether metadata 'Sync', 'Async',
               * or 'Deferred' is used
               *
               * Inline - The creation is done within the table. Not supported on a List Report
               *
               * External - The creation is done in a different application specified by the parameter 'outbound'
               *
               * CreationDialog - the creation is done in the table, with a dialog allowing to specify some initial property
               * values (the properties are listed in `creationDialogFields`)
               */
              creationMode: string;
              /**
               * The initial data for the created document
               */
              data?: object;
              /**
               * The navigation target where the document is created in case of creationMode 'External'
               */
              outbound?: string;
              /**
               * The contexts that are selected in the table initiating the creation. Used in case of a TreeTable to determine
               * the parent context of the created document
               */
              selectedContexts?: sap.ui.model.odata.v4.Context[];
              /**
               * When enabled, an extra request checks if any drafts exist that were never saved. If unsaved drafts are
               * found, the newest one is opened. If no unsaved drafts are found, a new entity is created
               */
              singleDraftForCreate?: boolean;
              /**
               * ID of the table
               */
              tableId?: string;
            }
          ): Promise<void>;
          /**
           * This function can be used to execute code on the mass edit save.
           * You can execute custom coding in this function.
           * If you decide to do your own save processing, you can return `true` to prevent the default save behavior.
           * This function is meant to be individually overridden by consuming controllers but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.Instead }.
           *
           *
           * @since 1.130.0
           *
           * @returns `true` to prevent the default execution, `false` to keep the standard behavior
           */
          customMassEditSave(
            /**
             * Object containing the parameters passed to customMassEditSave
             */
            _mParameters: {
              /**
               * Array containing the selected contexts for the mass edit
               */
              aContexts: sap.ui.model.odata.v4.Context[];
              /**
               * A dictionary containing the propertyPath and its value
               */
              oUpdateData: Record<string, any>;
            }
          ): Promise<boolean>;
          /**
           * Deletes the document.
           *
           * @since 1.90.0
           *
           * @returns Promise resolves once document has been deleted
           */
          deleteDocument(
            /**
             * Context of the document
             */
            oContext: sap.ui.model.odata.v4.Context,
            /**
             * Can contain the following attributes:
             */
            mInParameters?: {
              /**
               * Description of the object being deleted
               */
              description: string;
              /**
               * Title of the object being deleted
               */
              title: string;
            }
          ): Promise<void>;
          /**
           * Creates a draft document for the existing active document.
           *
           * @since 1.90.0
           *
           * @returns Promise resolved once the editable document is available with the editable context
           */
          editDocument(
            /**
             * Context of the active document
             */
            context: sap.ui.model.odata.v4.Context
          ): Promise<sap.ui.model.odata.v4.Context | void>;
          /**
           * Invokes an action (bound or unbound) and tracks the changes so that other pages can be refreshed and
           * show the updated data upon navigation.
           *
           * @since 1.90.0
           *
           * @returns A promise which resolves once the action has been executed. If resolved, the promise returns:
           * - If the parameter contexts is an array: an array of objects, each object containing a key "status",
           *     as well as "value" referencing the action status and the context
           * - If the parameter contexts is not an array: a single context
           * The context(s) provided in the promise is (are) either the return value context of the action or the
           * bound context if the return value is undefined.
           */
          invokeAction(
            /**
             * The name of the action to be called
             */
            sActionName: string,
            /**
             * Contains the following attributes:
             */
            mInParameters?: {
              /**
               * For a bound action, a context or an array with contexts for which the action is to be called must be
               * provided
               */
              contexts?:
                | sap.ui.model.odata.v4.Context
                | sap.ui.model.odata.v4.Context[];
              /**
               * Mode how actions are to be called: 'ChangeSet' to put all action calls into one changeset, 'Isolated'
               * to put them into separate changesets
               */
              invocationGrouping?: string;
              /**
               * A human-readable label for the action. This is needed in case the action has a parameter and a parameter
               * dialog is shown to the user. The label will be used for the title of the dialog and for the confirmation
               * button
               */
              label?: string;
              /**
               * For an unbound action, an instance of an OData V4 model must be provided
               */
              model?: sap.ui.model.odata.v4.ODataModel;
              /**
               * An optional array of objects representing the action parameters, where each object has a name of string
               * type and a value that can be of any data type.
               */
              parameterValues?: object[];
              /**
               * Boolean value indicating whether navigation is required after the action has been executed. Navigation
               * takes place to the context returned by the action
               */
              requiresNavigation?: boolean;
              /**
               * Skips the action parameter dialog if values are provided for all of them in parameterValues
               */
              skipParameterDialog?: boolean;
            }
          ): Promise<object[] | sap.ui.model.odata.v4.Context>;
          /**
           * This function can be used to execute code after the 'Create' action.
           * You can execute custom coding in this function.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.116.0
           *
           * @returns A promise to be returned by the overridden method.
           */
          onAfterCreate(
            /**
             * Object containing the parameters passed to onAfterCreate
             */
            _mParameters?: {
              /**
               * The newly created context
               */
              context?: sap.ui.model.odata.v4.Context;
            }
          ): Promise<void>;
          /**
           * This function can be used to execute code after the 'Delete' action.
           * You can execute custom coding in this function.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.116.0
           *
           * @returns A promise to be returned by the overridden method.
           */
          onAfterDelete(
            /**
             * Object containing the parameters passed to onAfterDelete
             */
            _mParameters?: {
              /**
               * An array of contexts that are going to be deleted
               */
              contexts?: sap.ui.model.odata.v4.Context[];
            }
          ): Promise<void>;
          /**
           * This function can be used to execute code after the 'Discard' action.
           * You can execute custom coding in this function.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.116.0
           *
           * @returns A promise to be returned by the overridden method.
           */
          onAfterDiscard(
            /**
             * Object containing the parameters passed to onAfterDiscard
             */
            _mParameters?: {
              /**
               * The context obtained after discarding the object, or undefined if we discarded a new object
               */
              context?: sap.ui.model.odata.v4.Context;
            }
          ): Promise<void>;
          /**
           * This function can be used to execute code after the 'Edit' action.
           * You can execute custom coding in this function.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.116.0
           *
           * @returns A promise to be returned by the overridden method.
           */
          onAfterEdit(
            /**
             * Object containing the parameters passed to onAfterEdit
             */
            _mParameters?: {
              /**
               * Page context that is going to be edited.
               */
              context?: sap.ui.model.odata.v4.Context;
            }
          ): Promise<void>;
          /**
           * This function can be used to execute code after the 'Save' action.
           * You can execute custom coding in this function.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.116.0
           *
           * @returns A promise to be returned by the overridden method.
           */
          onAfterSave(
            /**
             * Object containing the parameters passed to onAfterSave
             */
            _mParameters?: {
              /**
               * The context we obtained after saving
               */
              context?: sap.ui.model.odata.v4.Context;
            }
          ): Promise<void>;
          /**
           * This function can be used to intercept the 'Create' action. You can execute custom coding in this function.
           * The framework waits for the returned promise to be resolved before continuing the 'Create' action.
           * If you reject the promise, the 'Create' action is stopped.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.98.0
           *
           * @returns A promise to be returned by the overridden method. If resolved, the 'Create' action is triggered.
           * If rejected, the 'Create' action is not triggered.
           */
          onBeforeCreate(
            /**
             * Object containing the parameters passed to onBeforeCreate
             */
            _mParameters?: {
              /**
               * Path pointing to the context on which Create action is triggered
               */
              contextPath?: string;
              /**
               * Array of values that are filled in the Action Parameter Dialog
               */
              createParameters?: any[];
            }
          ): Promise<void>;
          /**
           * This function can be used to intercept the 'Delete' action. You can execute custom coding in this function.
           * The framework waits for the returned promise to be resolved before continuing the 'Delete' action.
           * If you reject the promise, the 'Delete' action is stopped.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.98.0
           *
           * @returns A promise to be returned by the overridden method. If resolved, the 'Delete' action is triggered.
           * If rejected, the 'Delete' action is not triggered.
           */
          onBeforeDelete(
            /**
             * Object containing the parameters passed to onBeforeDelete
             */
            _mParameters?: {
              /**
               * An array of contexts that are going to be deleted
               */
              contexts?: sap.ui.model.odata.v4.Context[];
            }
          ): Promise<void>;
          /**
           * This function can be used to intercept the 'Discard' action. You can execute custom coding in this function.
           * The framework waits for the returned promise to be resolved before continuing the 'Discard' action.
           * If you reject the promise, the 'Discard' action is stopped and the user stays in edit mode.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.98.0
           *
           * @returns A promise to be returned by the overridden method. If resolved, the 'Discard' action is triggered.
           * If rejected, the 'Discard' action is not triggered and the user stays in edit mode.
           */
          onBeforeDiscard(
            /**
             * Object containing the parameters passed to onBeforeDiscard
             */
            _mParameters?: {
              /**
               * Page context that is going to be discarded.
               */
              context?: sap.ui.model.odata.v4.Context;
            }
          ): Promise<void>;
          /**
           * This function can be used to intercept the 'Edit' action. You can execute custom coding in this function.
           * The framework waits for the returned promise to be resolved before continuing the 'Edit' action.
           * If you reject the promise, the 'Edit' action is stopped and the user stays in display mode.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.98.0
           *
           * @returns A promise to be returned by the overridden method. If resolved, the 'Edit' action is triggered.
           * If rejected, the 'Edit' action is not triggered and the user stays in display mode.
           */
          onBeforeEdit(
            /**
             * Object containing the parameters passed to onBeforeEdit
             */
            _mParameters?: {
              /**
               * Page context that is going to be edited.
               */
              context?: sap.ui.model.odata.v4.Context;
            }
          ): Promise<void>;
          /**
           * This function can be used to intercept the 'Save' action. You can execute custom coding in this function.
           * The framework waits for the returned promise to be resolved before continuing the 'Save' action.
           * If you reject the promise, the 'Save' action is stopped and the user stays in edit mode.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.90.0
           *
           * @returns A promise to be returned by the overridden method. If resolved, the 'Save' action is triggered.
           * If rejected, the 'Save' action is not triggered and the user stays in edit mode.
           */
          onBeforeSave(
            /**
             * Object containing the parameters passed to onBeforeSave
             */
            _mParameters?: {
              /**
               * Page context that is going to be saved.
               */
              context?: sap.ui.model.odata.v4.Context;
            }
          ): Promise<void>;
          /**
           * Saves a new document after checking it.
           *
           * @since 1.90.0
           *
           * @returns Promise resolves once save is complete
           */
          saveDocument(
            /**
             * Context of the editable document
             */
            oContext: sap.ui.model.odata.v4.Context
          ): Promise<void>;
          /**
           * Secured execution of the given function. Ensures that the function is only executed when certain conditions
           * are fulfilled.
           *
           * @since 1.90.0
           *
           * @returns A promise that is rejected if the execution is prohibited and resolved by the promise returned
           * by the fnFunction.
           */
          securedExecution(
            /**
             * The function to be executed. Should return a promise that is settled after completion of the execution.
             * If nothing is returned, immediate completion is assumed.
             */
            fnFunction: Function,
            /**
             * Definitions of the preconditions to be checked before execution
             */
            mParameters?: {
              /**
               * Defines the busy indicator
               */
              busy?: {
                /**
                 * Executes function only if application isn't busy.
                 */
                check?: boolean;
                /**
                 * Triggers a busy indicator when the function is executed.
                 */
                set?: boolean;
              };
              /**
               * This operation updates the current document without using the bound model and context. As a result, the
               * draft status is updated if a draft document exists, and the user has to confirm the cancellation of the
               * editing process.
               */
              updatesDocument?: boolean;
            }
          ): Promise<void>;
          /**
           * Updates the draft status and displays the error messages if there are errors during an update.
           *
           * @since 1.90.0
           *
           * @returns Promise resolves once draft status has been updated
           */
          updateDocument(
            /**
             * Context of the updated field
             */
            updatedContext:
              | sap.ui.model.Binding
              | sap.ui.model.odata.v4.Context,
            /**
             * Promise to determine when the update operation is completed. The promise should be resolved when the
             * update operation is completed, so the draft status can be updated.
             */
            updatePromise: Promise<any>
          ): Promise<void>;
        }
        /**
         * Controller extension providing hooks for intent-based navigation
         * {@link demo:sap/fe/core/fpmExplorer/index.html#/controllerExtensions/intentBasedNavigation Overview of Building Blocks}
         *
         * @since 1.86.0
         */
        class IntentBasedNavigation extends sap.ui.core.mvc
          .ControllerExtension {
          /**
           * Provides a hook to customize the {@link sap.fe.navigation.SelectionVariant } related to the intent-based
           * navigation.
           *
           * @since 1.86.0
           */
          adaptNavigationContext(
            /**
             * SelectionVariant provided by SAP Fiori elements.
             */
            _oSelectionVariant: sap.fe.navigation.SelectionVariant,
            /**
             * Object containing intent-based navigation-related info
             */
            _oNavigationInfo: {
              /**
               * Action related to the intent
               */
              action: string;
              /**
               * Semantic object related to the intent
               */
              semanticObject: string;
            }
          ): void;
          /**
           * Navigates to an intent defined by an outbound definition in the manifest.
           *
           * @since 1.86.0
           */
          navigateOutbound(
            /**
             * Identifier to locate the outbound definition in the manifest.
             * This provides the semantic object and action for the intent-based navigation.
             * Additionally, the outbound definition can be used to provide parameters for intent-based navigation.
             * See {@link topic :be0cf40f61184b358b5faedaec98b2da Descriptor for Applications, Components, and Libraries }
             * for more information.
             */
            sOutbound: string,
            /**
             * Optional map containing key/value pairs to be passed to the intent.
             * If mNavigationParameters are provided, the parameters provided in the outbound definition of the manifest
             * are ignored.
             */
            mNavigationParameters?: Record<string, any>
          ): void;
        }
        /**
         * A controller extension offering message handling.
         *
         * @since 1.90.0
         * @experimental As of version 1.90.0.
         */
        class MessageHandler extends sap.ui.core.mvc.ControllerExtension {
          /**
           * Allows consumer of a message button BB to decide which bound messages should be shown and how.
           * This hook is called when the message button BB detects a change in the message model.
           * The hooks allows to define behaviour for messages in the message button BB.
           * Consumers will be able to do the following with this hook.
           * 1. Filter out messages so that they are not shown on the message button.
           * 2. group the messages based on their UI.
           * 3. provide a presser handler incase the message should show as a link.
           *
           *
           * @experimental
           *
           * @returns A promise that must be returned by the overridden method.
           */
          beforeShowMessageButton(
            /**
             * Object containing the details related to the message.
             */
            _messageDetails: sap.fe.core.controllerextensions.MessageHandler.MessageDetail[]
          ): Promise<void>;
          /**
           * Shows a message dialog with transition messages if there are any.
           * The message dialog is shown as a modal dialog. Once the user confirms the dialog, all transition messages
           * are removed from the message model. If there is more than one message, a list of messages is shown. The
           * user
           * can filter on message types and can display details as well as the long text. If there is one message,
           * the dialog immediately shows the details of the message. If there is just one success message, a message
           * toast is shown instead.
           *
           * @since 1.90.0
           * @experimental As of version 1.90.0.
           *
           * @returns A promise that is resolved once the user closes the dialog. If there are no messages
           * to be shown, the promise is resolved immediately
           */
          showMessageDialog(): Promise<void>;
        }
        /**
         * Controller extension providing hooks for the navigation using paginators
         *
         * @since 1.94.0
         */
        class Paginator extends sap.ui.core.mvc.ControllerExtension {
          /**
           * Initiates the paginator control.
           *
           * @since 1.94.0
           */
          initialize(
            /**
             * ODataListBinding object
             */
            oBinding?: sap.ui.model.odata.v4.ODataListBinding,
            /**
             * Current context where the navigation is initiated
             */
            oContext?: sap.ui.model.odata.v4.Context
          ): void;
          /**
           * Returns the updated context after the paginator operation.
           *
           * @since 1.94.0
           */
          onContextUpdate(
            /**
             * Final context returned after the paginator action
             */
            oContext: sap.ui.model.odata.v4.Context
          ): void;
        }
        /**
         * A controller extension offering hooks into the routing flow of the application
         *
         * @since 1.86.0
         */
        class Routing extends sap.fe.core.controllerextensions
          .BaseControllerExtension {
          /**
           * Allows navigation to a specific context.
           *
           * @since 1.90.0
           */
          navigate(
            /**
             * Object containing the context to be navigated to
             */
            oContext: sap.ui.model.odata.v4.Context,
            /**
             * Object containing the parameters for the navigation
             */
            parameters?: {
              /**
               * By default, the internal algorithm decides whether the navigation preserves the previous entry. This
               * parameter allows you to override this behavior.
               */
              preserveHistory: boolean;
            }
          ): void;
          /**
           * Navigate to another target.
           *
           *
           * @returns Promise that is resolved when the navigation is finalized
           */
          navigateToRoute(
            /**
             * Name of the target route
             */
            sTargetRouteName: string,
            /**
             * Parameters to be used with route to create the target hash
             */
            oParameters?: object
          ): Promise<boolean>;
          /**
           * This function is used to intercept the routing event after binding a page.
           * If it is declared as an extension, it allows you to intercept and change the normal flow of binding.
           * This function is not called directly, but overridden separately by consuming controllers.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.90.0
           */
          onAfterBinding(
            /**
             * Object containing the context to be navigated
             */
            oContext: null | object
          ): void;
          /**
           * This function is used to intercept the routing event before binding a page.
           * If it is declared as an extension, it allows you to intercept and change the normal flow of binding.
           * This function is not called directly, but overridden separately by consuming controllers.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.90.0
           */
          onBeforeBinding(
            /**
             * Object containing the context for the navigation
             */
            oContext: null | object
          ): void;
          /**
           * This function can be used to intercept the routing event during the normal navigation process, such as
           * when a table row is clicked to navigate, pagination buttons are used, the Apply button in an object page
           * is clicked, or a sub-object page in a flexible column layout is closed.
           * The function is NOT called during other means of external outbound navigation (like a navigation configured
           * via a link, or by using navigation buttons).
           * If declared as an extension, it allows you to intercept and change the normal navigation flow.
           * If you decide to do your own navigation processing, you can return `true` to prevent the default routing
           * behavior.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @since 1.86.0
           *
           * @returns `true` to prevent the default execution, false to keep the standard behavior
           */
          onBeforeNavigation(
            /**
             * Object containing row context and page context
             */
            mNavigationParameters: {
              /**
               * The target navigation context
               */
              bindingContext: sap.ui.model.odata.v4.Context;
            }
          ): Promise<boolean>;
        }
        /**
         * A controller extension offering hooks into the routing flow of the application
         *
         * @since 1.86.0
         */
        class Share extends sap.fe.core.controllerextensions
          .BaseControllerExtension {
          /**
           * Adapts the metadata used while sharing the page URL via 'Send Email', 'Share in SAP Jam', and 'Save as
           * Tile'.
           *
           * @since 1.93.0
           *
           * @returns Share Metadata or a Promise resolving the Share Metadata
           */
          adaptShareMetadata(
            /**
             * Object containing the share metadata.
             */
            oShareMetadata: {
              /**
               * Email-specific metadata.
               */
              email: {
                /**
                 * Title that will be used as "email subject" in 'Send Email'. This takes precedence over oShareMetadata.title.
                 */
                title: string;
                /**
                 * URL that will be used specifically for 'Send Email'. This takes precedence over oShareMetadata.url.
                 */
                url: string;
              };
              /**
               * SAP Jam-specific metadata.
               */
              jam: {
                /**
                 * Title that will be used as 'share text' in 'Share in SAP Jam'. This takes precedence over oShareMetadata.title.
                 */
                title: string;
                /**
                 * URL that will be used specifically for 'Share in SAP Jam'. This takes precedence over oShareMetadata.url.
                 */
                url?: string;
              };
              /**
               * Save as Tile-specific metadata.
               */
              tile: {
                /**
                 * Icon to be used for the tile.
                 */
                icon?: string;
                /**
                 * Query URL of an OData service from which data for a dynamic tile is read.
                 */
                queryUrl?: string;
                /**
                 * Subtitle to be used for the tile.
                 */
                subtitle: string;
                /**
                 * Title to be used for the tile. This takes precedence over oShareMetadata.title.
                 */
                title: string;
                /**
                 * URL that will be used specifically for 'Save as Tile'. This takes precedence over oShareMetadata.url.
                 */
                url?: string;
              };
              /**
               * Default title that will be used as 'email subject' in 'Send Email', 'share text' in 'Share in SAP Jam'
               * and 'title' in 'Save as Tile'
               */
              title: string;
              /**
               * Default URL that will be used via 'Send Email', 'Share in SAP Jam', and 'Save as Tile'
               */
              url: string;
            }
          ):
            | Promise</* was: sap.fe.core.controllerextensions.Share.ShareMetadata */ any>
            | /* was: sap.fe.core.controllerextensions.Share.ShareMetadata */ any;
          /**
           * Opens the share sheet.
           *
           * @since 1.93.0
           */
          openShareSheet(
            /**
             * The control to which the ActionSheet is opened.
             */
            oControl: sap.ui.core.Control
          ): void;
        }
        /**
         * A controller extension offering hooks for state handling
         * If you need to maintain a specific state for your application, you can use the controller extension.
         *
         *
         * @since 1.85.0
         */
        class ViewState extends sap.ui.core.mvc.ControllerExtension {
          /**
           * This function should add all controls relevant for refreshing to the provided control array.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           */
          adaptBindingRefreshControls(
            /**
             * The collected controls
             */
            aCollectedControls: sap.ui.base.ManagedObject[]
          ): void;
          /**
           * Customize the `refreshBinding` function for a certain control.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           */
          adaptBindingRefreshHandler(
            /**
             * The control for which the refresh handler is adapted.
             */
            _oControl: sap.ui.base.ManagedObject,
            /**
             * A plain object which can have one function: `refreshBinding`
             */
            _oControlHandler: object
          ): void;
          /**
           * Customize the `retrieve` and `apply` functions for a certain control.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           */
          adaptControlStateHandler(
            /**
             * The control to get state handler for
             */
            oControl: sap.ui.base.ManagedObject,
            /**
             * A list of plain objects with two functions: `retrieve` and `apply`
             */
            aControlHandler: object[]
          ): void;
          /**
           * This function should add all controls for given view that should be considered for the state handling
           * to the provided control array.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           */
          adaptStateControls(
            /**
             * The collected controls
             */
            _aCollectedControls: sap.ui.base.ManagedObject[]
          ): void;
          /**
           * Applying additional, not control related, states - is called only if navigation type is iAppState.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           */
          applyAdditionalStates(
            /**
             * The current view state
             */
            oViewState: object,
            /**
             * Extensible array of promises to be resolved before continuing
             */
            aPromises: Promise<any>
          ): void;
          /**
           * Defines whether the view state should only be applied once initially.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.Instead }.
           * Important:
           * You should only override this method for custom pages and not for the standard ListReportPage and ObjectPage!
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           *
           * @returns If `true`, only the initial view state is applied once,
           * else any new view state is also applied on follow-up calls (default)
           */
          applyInitialStateOnly(): boolean;
          /**
           * Apply navigation parameters is not called if the navigation type is iAppState
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           */
          applyNavigationParameters(
            /**
             * The current navigation parameter
             */
            oNavParameter: sap.fe.core.controllerextensions.ViewState.NavigationParameter,
            /**
             * Extensible array of promises to be resolved before continuing
             */
            aPromises: Promise<any>
          ): void;
          /**
           * Applies the given view state to this extensions view.
           *
           *
           * @returns Promise for async state handling
           */
          applyViewState(
            /**
             * The view state to apply (can be undefined)
             */
            oViewState: Record<string, any> | undefined,
            /**
             * The current navigation parameter
             */
            oNavParameter: sap.fe.core.controllerextensions.ViewState.NavigationParameter,
            /**
             * Boolean which determines to skip the key user shine through
             */
            skipMerge?: boolean
          ): Promise<void>;
          /**
           * Hook to react when state for given view was applied.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           */
          onAfterStateApplied(
            /**
             * Extensible array of promises to be resolved before continuing
             */
            aPromises: Promise<any>
          ): void;
          /**
           * Hook to react before a state for given view is applied.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           */
          onBeforeStateApplied(
            /**
             * Extensible array of promises to be resolved before continuing
             */
            aPromises: any,
            /**
             * Navigation type responsible for the applying the state
             */
            navigationType?: string
          ): void;
          /**
           * Called when the application is restored due to keep-alive mode.
           */
          onRestore(): void;
          /**
           * Called when the application is suspended due to keep-alive mode.
           */
          onSuspend(): void;
          /**
           * Extend the map of additional states (not control bound) to be added to the current view state of the
           * given view.
           * This function is meant to be individually overridden by consuming controllers, but not to be called directly.
           * The override execution is: {@link sap.ui.core.mvc.OverrideExecution.After }.
           *
           *
           * @ui5-protected Do not call from applications (only from related classes in the framework)
           */
          retrieveAdditionalStates(
            /**
             * The additional state
             */
            mAdditionalStates: object
          ): void;
          /**
           * Retrieve the view state of this extensions view.
           *
           *
           * @returns A promise resolving the view state
           */
          retrieveViewState(): Promise<Record<string, any> | undefined>;
        }
      }
      /**
       * Collection of classes provided by SAP Fiori elements for the Flexible Programming Model
       */
      namespace fpm {
        /**
         * Component that can be used as a wrapper component for custom pages.
         * The component can be used in case you want to use SAP Fiori elements Building Blocks or XML template
         * constructions. You can either extend the component and set the viewName and contextPath within your code
         * or you can use it to wrap your custom XML view directly the manifest when you define your custom page
         * under sapui5/routing/targets:
         *
         * ```javascript
         *
         * "myCustomPage": {
         *  "type": "Component",
         *  "id": "myCustomPage",
         *  "name": "sap.fe.core.fpm",
         *  "title": "My Custom Page",
         *  "options": {
         * 	"settings": {
         * 		"viewName": "myNamespace.myView",
         * 		"contextPath": "/MyEntitySet"
         * 	}
         *  }
         *  }
         * ```
         *
         *
         *
         * @since 1.92.0
         * @experimental As of version 1.92.0.
         */
        class Component
          extends /* was: sap.fe.core.TemplateComponent */ Object
        {
          /**
           * Returns the current AppComponent.
           *
           *
           * @returns The current AppComponent
           */
          getAppComponent(): sap.fe.core.AppComponent;
        }
      }

      namespace buildingBlocks {
        /**
         * Describes the settings that can be provided to the BuildingBlock constructor.
         *
         * @experimental As of version 1.121.0.
         */
        interface $BuildingBlockSettings
          extends sap.fe.base.$BuildingBlockBaseSettings {}

        /**
         * Defines a control that will not exist in the DOM.
         * Instead, only its child will be there and this control will forward all DOM related instruction to it.
         *
         * @since 1.121.0
         * @experimental As of version 1.121.0.
         */
        class BuildingBlock extends sap.fe.base.BuildingBlockBase {}
      }

      namespace controls {
        namespace DataWatcher {
          /**
           * A callback function that is called when the value of the watched property changes.
           */
          type WatcherCallback = {};
        }
      }

      namespace rootView {
        /**
         * Base controller class for your own root view with an sap.f.FlexibleColumnLayout control.
         * By using or extending this controller, you can use your own root view with the sap.fe.core.AppComponent
         * and
         * you can make use of SAP Fiori elements pages and SAP Fiori elements building blocks.
         *
         *
         * @since 1.110.0
         */
        class Fcl
          extends /* was: sap.fe.core.rootView.RootViewBaseController */ Object {}
        /**
         * Base controller class for your own root view with a sap.m.NavContainer control.
         * By using or extending this controller you can use your own root view with the sap.fe.core.AppComponent
         * and
         * you can make use of SAP Fiori elements pages and SAP Fiori elements building blocks.
         *
         *
         * @since 1.108.0
         */
        class NavContainer
          extends /* was: sap.fe.core.rootView.RootViewBaseController */ Object {}
      }
      /**
       * Describes the settings that can be provided to the AppComponent constructor.
       */
      interface $AppComponentSettings
        extends sap.ui.core.$UIComponentSettings {}

      /**
       * Main class for components used for an application in SAP Fiori elements.
       * Application developers using the templates and building blocks provided by SAP Fiori elements should
       * create their apps by extending this component.
       * This ensures that all the necessary services that you need for the building blocks and templates to work
       * properly are started.
       * When you use sap.fe.core.AppComponent as the base component, you also need to use a rootView. SAP Fiori
       * elements provides two options:
       *
       * - sap.fe.core.rootView.NavContainer when using sap.m.routing.Router
       *
       * - sap.fe.core.rootView.Fcl when using sap.f.routing.Router (FCL use case)
       */
      class AppComponent
        extends sap.ui.core.UIComponent
        implements sap.ui.core.IAsyncContentCreation
      {
        __implements__sap_ui_core_IAsyncContentCreation: boolean;

        /**
         * Changes the page configuration of SAP Fiori elements.
         * This method enables you to change the page configuration of SAP Fiori elements.
         */
        changePageConfiguration(
          /**
           * The ID of the page for which the configuration is to be changed.
           */
          pageId: string,
          /**
           * The path in the page settings for which the configuration is to be changed.
           */
          path: string,
          /**
           * The new value of the configuration. This could be a plain value like a string, or a Boolean, or a structured
           * object.
           */
          value: any
        ): void;
        /**
         * Provides a hook to initialize feature toggles.
         * This hook is being called by the SAP Fiori elements AppComponent at the time feature toggles can be initialized.
         * To change page configuration, use the {@link sap.fe.core.AppComponent#changePageConfiguration } method.
         *
         *
         *
         * @returns A promise without any value to allow asynchronous processes
         */
        initializeFeatureToggles(): Promise<void>;
      }
      /**
       * Internal base controller class for SAP Fiori elements application.
       * If you want to extend a base controller for your custom page, please use for sap.fe.core.PageController.
       *
       *
       * @since 1.90.0
       */
      class BaseController extends sap.ui.core.mvc.Controller {
        /**
         * Returns the current app component.
         *
         * @since 1.91.0
         *
         * @returns The app component or, if not found, null
         */
        getAppComponent(): sap.fe.core.AppComponent;
        /**
         * Convenience method provided by SAP Fiori elements to enable applications to include the view model by
         * name into each controller.
         *
         *
         * @returns The model instance
         */
        getModel(
          /**
           * The model name
           */
          sName?: string
        ): sap.ui.model.Model | undefined;
        /**
         * Convenience method for setting the view model in every controller of the application.
         *
         *
         * @returns The view instance
         */
        setModel(
          /**
           * The model instance
           */
          oModel: sap.ui.model.Model,
          /**
           * The model name
           */
          sName: string
        ): sap.ui.core.mvc.View;
      }
      /**
       * Common Extension API for all pages of SAP Fiori elements for OData V4.
       * To correctly integrate your app extension coding with SAP Fiori elements, use only the extensionAPI of
       * SAP Fiori elements. Don't access or manipulate controls, properties, models, or other internal objects
       * created by the SAP Fiori elements framework.
       * {@link demo:sap/fe/core/fpmExplorer/index.html#/controllerExtensions/controllerExtensionsOverview Overview of Building Block}
       *
       *
       * @since 1.79.0
       */
      class ExtensionAPI extends sap.ui.base.Object {
        /**
         * Add any control as a dependent control to this SAP Fiori elements page.
         */
        addDependent(
          /**
           * Control to be added as a dependent control
           */
          oControl: sap.ui.core.Control
        ): void;
        /**
         * Access a control by its ID. If you attempt to access an internal control instead of the stable API, the
         * method will raise an error.
         *
         *
         * @returns The requested control, if found in the view / section.
         */
        byId(
          /**
           * ID of the control without view and section prefix.
           */
          id: string
        ): sap.ui.core.Element | undefined;
        /**
         * Retrieves the editFlow controller extension for this page.
         *
         *
         * @returns The editFlow controller extension
         */
        getEditFlow(): sap.fe.core.controllerextensions.EditFlow;
        /**
         * Retrieves the intentBasedNavigation controller extension for this page.
         *
         *
         * @returns The intentBasedNavigation controller extension
         */
        getIntentBasedNavigation(): sap.fe.core.controllerextensions.IntentBasedNavigation;
        /**
         * Get access to models managed by SAP Fiori elements.
         *
         * The following models can be accessed:
         *
         *
         * 	 - undefined: the undefined model returns the SAPUI5 OData V4 model bound to this page
         *
         * 	 - i18n / further data models defined in the manifest
         * ui: returns a SAPUI5 JSON model containing UI information.
         * Only the following properties are public and supported:
         *
         *
         * 	 - isEditable: set to true if the application is in edit mode
         *
         *
         * .
         * editMode is deprecated and should not be used anymore. Use isEditable instead.
         *
         *
         * @returns The required model
         */
        getModel(
          /**
           * Name of the model
           */
          sModelName?: string
        ): sap.ui.model.Model | undefined;
        /**
         * Retrieves the routing controller extension for this page.
         *
         *
         * @returns The routing controller extension
         */
        getRouting(): sap.fe.core.controllerextensions.Routing;
        /**
         * Load a fragment and go through the template preprocessor with the current page context.
         *
         *
         * @returns The fragment definition
         */
        loadFragment(
          /**
           * The settings object
           */
          mSettings: {
            /**
             * The contextPath to be used for the templating process
             */
            contextPath?: string;
            /**
             * The controller to be attached to the fragment
             */
            controller?: object;
            /**
             * The ID of the fragment itself
             */
            id: string;
            /**
             * The initial binding context
             */
            initialBindingContext?: sap.ui.model.Context;
            /**
             * The name of the fragment to be loaded
             */
            name: string;
          }
        ): Promise<sap.ui.core.Element | sap.ui.core.Element[]>;
        /**
         * Navigate to another target.
         */
        navigateToTarget(
          /**
           * Name of the target route
           */
          sTarget: string,
          /**
           * OData v4 context instance
           */
          oContext: sap.ui.model.odata.v4.Context
        ): void;
        /**
         * Remove a dependent control from this SAP Fiori elements page.
         */
        removeDependent(
          /**
           * Control to be added as a dependent control
           */
          oControl: sap.ui.core.Control
        ): void;
        /**
         * Run the given function with the FPM context of the current page.
         * This allows to initialize all the elements required by building blocks to render correctly.
         *
         *
         * @returns The result of the function
         */
        runWithFPMContext(
          /**
           * The Function to be executed
           */
          fn: Function
        ): any;
        /**
         * Triggers an update of the app state.
         * Should be called if the state of a control, or any other state-relevant information, was changed.
         *
         *
         * @returns A promise that resolves with the new app state object.
         */
        updateAppState(): Promise<object | void>;
        /**
         * Watch a property from the main page context and trigger a callback when the value changes.
         */
        watchProperty(
          /**
           * The name of the property to watch
           */
          propertyName: string,
          /**
           * The callback to trigger when the value changes
           */
          callback: sap.fe.core.controls.DataWatcher.WatcherCallback
        ): void;
      }
      /**
       * Base controller class for your custom page used inside an SAP Fiori elements application.
       * This controller provides preconfigured extensions that will ensure you have the basic functionalities
       * required to use the building blocks.
       *
       *
       * @since 1.88.0
       */
      class PageController extends sap.fe.core.BaseController {
        /**
         * Get the extension API for the current page.
         *
         *
         * @returns The extension API.
         */
        getExtensionAPI(): sap.fe.core.ExtensionAPI;
      }
      /**
       * Possible initial load (first app startup) modes for a ListReport.
       *
       * @since 1.86.0
       */
      enum InitialLoadMode {
        /**
         * Data will be loaded initially if filters are set.
         */
        Auto = "undefined",
        /**
         * Data will not be loaded initially.
         */
        Disabled = "undefined",
        /**
         * Data will be loaded initially.
         */
        Enabled = "undefined",
      }
    }
  }

  interface IUI5DefineDependencyNames {
    "sap/fe/core/AppComponent": undefined;

    "sap/fe/core/BaseController": undefined;

    "sap/fe/core/buildingBlocks/BuildingBlock": undefined;

    "sap/fe/core/controllerextensions/BaseControllerExtension": undefined;

    "sap/fe/core/controllerextensions/EditFlow": undefined;

    "sap/fe/core/controllerextensions/IntentBasedNavigation": undefined;

    "sap/fe/core/controllerextensions/MessageHandler": undefined;

    "sap/fe/core/controllerextensions/Paginator": undefined;

    "sap/fe/core/controllerextensions/Routing": undefined;

    "sap/fe/core/controllerextensions/Share": undefined;

    "sap/fe/core/controllerextensions/ViewState": undefined;

    "sap/fe/core/controls/DataWatcher": undefined;

    "sap/fe/core/ExtensionAPI": undefined;

    "sap/fe/core/fpm/Component": undefined;

    "sap/fe/core/library": undefined;

    "sap/fe/core/PageController": undefined;

    "sap/fe/core/rootView/Fcl.controller": undefined;

    "sap/fe/core/rootView/NavContainer.controller": undefined;
  }
}
