API Reference

Script Reference

ISN_UIApplication

namespace SA.iOS.UIKit
...
/// <summary>
/// The centralized point of control and coordination for apps running in iOS.
/// </summary>
public class ISN_UIApplication
{
    /// <summary>
    /// The number currently set as the badge of the app icon in Springboard.
    /// Set to 0 (zero) to hide the badge number. The default value of this property is 0.
    /// </summary>
    public static long ApplicationBagesNumber {get;set;}

    /// <summary>
    /// Returns a Boolean value indicating whether or not the URL’s scheme can be handled 
    /// by some app installed on the device.
    /// </summary>
    /// <param name="url">A URL (Universal Resource Locator). 
    /// At runtime, the system tests the URL’s scheme to determine if there is an 
    /// installed app that is registered to handle the scheme. 
    /// More than one app can be registered to handle a scheme.
    /// The URL you pass to this method can have a common scheme or a custom scheme.
    /// </param>
    public static bool CanOpenURL(string url);

    /// <summary>
    /// Attempts to open the resource at the specified URL asynchronously.
    /// 
    /// Use this method to open the specified resource. 
    /// If the specified URL scheme is handled by another app, iOS launches that app 
    /// and passes the URL to it.
    /// To determine whether an app is installed that is capable of handling the URL, 
    /// call the <see cref="CanOpenURL"/> method before calling this one. 
    /// Be sure to read the description of that method for an important note 
    /// about registering the schemes you want to employ.
    /// </summary>
    /// <param name="url">URL.</param>
    public static void OpenURL(string url);

    /// <summary>
    /// A set of methods that are called in response to important events in the lifetime 
    /// of your app.
    /// </summary>
    public static ISN_UIApplicationDelegate ApplicationDelegate {get;}
}

ISN_UIImagePickerController

namespace SA.IOSNative.UIKit
...
/// <summary>
/// A view controller that manages the system interfaces for taking pictures, recording movies, 
/// and choosing items from the user's media library.
/// </summary>
public class ISN_UIImagePickerController 
{
    //--------------------------------------
    // Public Methods
    //--------------------------------------

    /// <summary>
    /// Presents a view controller modally.
    /// 
    /// If you configured the view controller to use 
    /// <see cref="ISN_UIImagePickerControllerSourceType.Camera"/>,
    /// the <see cref="ISN_AVMediaType.Video"/> permission will be checked automatically, 
    /// before presenting view controller. You can always do this yourself using the 
    /// <see cref="ISN_AVCaptureDevice.RequestAccess"/>
    /// </summary>
    /// <param name="callback">Callback.</param>
    public void Present(Action<ISN_UIPickerControllerResult> callback);

    //--------------------------------------
    // Get / Set 
    //--------------------------------------

    /// <summary>
    /// An array indicating the media types to be accessed by the media picker controller.
    /// 
    /// Depending on the media types you assign to this property, 
    /// the picker displays a dedicated interface for still images or movies, 
    /// or a selection control that lets the user choose the picker interface. 
    /// Before setting this property, 
    /// check which media types are available by calling the 
    /// <see cref="GetAvailableMediaTypes"/> class method.
    /// 
    /// If you set this property to an empty array, 
    /// or to an array in which none of the media types is available for the current source, 
    /// the system throws an exception.
    /// </summary>
    public List<string> MediaTypes;

    /// <summary>
    /// The type of picker interface to be displayed by the controller.
    /// 
    /// Prior to running the picker interface, set this value to the desired source type. 
    /// The source type you set must be available and an exception is thrown if it is not. 
    /// If you change this property while the picker is visible, 
    /// the picker interface changes to match the new value in this property.
    /// The various source types are listed in the 
    /// <see cref="ISN_UIImagePickerControllerSourceType"/> enumeration.
    /// The default value is <see cref="ISN_UIImagePickerControllerSourceType.PhotoLibrary"/>.
    /// </summary>
    public ISN_UIImagePickerControllerSourceType SourceType;

    /// <summary>
    /// A Boolean value indicating whether the user is allowed to edit a selected still 
    /// image or movie.
    /// This property is set to false by default.
    /// </summary>
    public bool AllowsEditing;

    /// <summary>
    /// Is <see cref="ImageCompressionFormat"/> is set tp 
    /// <see cref="ISN_UIImageCompressionFormat.JPEG"/>
    /// commpression format value will be applayed.
    /// 
    /// The default value is 0.8f
    /// </summary>
    public float ImageCompressionRate;
    /// <summary>
    /// Max allowed image size. If bigger image is picked by user, image will be resized 
    /// before sending to Unity.
    /// Most of the images in user photo library are big, so it's better to use this 
    /// property to save some RAM.
    /// 
    /// The defaul value is 512
    /// </summary>
    /// <value>The size of the max image.</value>
    public int MaxImageSize;

    /// <summary>
    /// Image compression format. 
    /// Default value is JPEG
    /// </summary>
    public ISN_UIImageCompressionFormat ImageCompressionFormat;

    //--------------------------------------
    // Static Methods
    //--------------------------------------

    /// <summary>
    /// Adds a photo to the saved photos album.
    /// </summary>
    /// <param name="texture">Texture you want to save to the album.</param>
    /// <param name="callback">Callback.</param>
    public static void SaveTextureToCameraRoll(Texture2D texture, Action<SA_Result> callback);

    /// <summary>
    /// Saves the screen screenshot to the saved photos album.
    /// </summary>
    /// <param name="callback">Callback.</param>
    public static void SaveScreenshotToCameraRoll(Action<SA_Result> callback);

    /// <summary>
    /// Returns an array of the available media types for the specified source type.
    /// 
    /// Some iOS devices support video recording. 
    /// Use this method, along with the <see cref="IsSourceTypeAvailable"/> method, 
    /// to determine if video recording is available on a device.
    /// </summary>
    /// <returns>The available media types.</returns>
    /// <param name="sourceType">The source to use to pick an image.</param>
    public static List<string> GetAvailableMediaTypes(ISN_UIImagePickerControllerSourceType sourceType);

    /// <summary>
    /// Returns a Boolean value indicating whether the device supports picking media 
    /// using the specified source type.
    /// 
    /// Because a media source may not be present or may be unavailable, 
    /// devices may not always support all source types. 
    /// For example, if you attempt to pick an image from the user’s library and the 
    /// library is empty, this method returns <c>false</c>. 
    /// Similarly, if the camera is already in use, this method returns <c>false</c>.
    //
    /// Before attempting to use an <see cref="ISN_UIImagePickerController"/> object 
    /// to pick an image,  you must call this method to ensure that the desired 
    /// source type is available.
    /// </summary>
    public static bool IsSourceTypeAvailable(ISN_UIImagePickerControllerSourceType sourceType);
}

ISN_UIDevice

namespace SA.IOSNative.UIKit
...
/// <summary>
/// A representation of the current device.
/// </summary>
public class ISN_UIDevice
{ 

    /// <summary>
    /// Returns an object representing the current device.
    /// You access the properties of the returned <see cref="ISN_UIDevice"/> 
    /// instance to obtain information about the device.
    /// </summary>
    public static ISN_UIDevice CurrentDevice {get;}

    /// <summary>
    /// The name identifying the device.
    /// The value of this property is an arbitrary alphanumeric string that is associated 
    /// with the device as an identifier. 
    /// For example, you can find the name of an iOS device in the General > About settings.
    /// </summary>
    public string Name {get;}

    /// <summary>
    /// The name of the operating system running on the device represented by the receiver.
    /// </summary>
    public string SystemName {get;}

    /// <summary>
    /// The model of the device.
    /// Possible examples of model strings are ”iPhone” and ”iPod touch”.
    /// </summary>
    public string Model {get;}

    /// <summary>
    /// The model of the device as a localized string.
    /// The value of this property is a string that contains a localized version 
    /// of the string returned from <see cref="Model"/>.
    /// </summary>
    public string LocalizedModel {get;}

    /// <summary>
    /// The current version of the operating system.
    /// </summary>
    public string SystemVersion {get;}

    /// <summary>
    /// The style of interface to use on the current device.
    /// 
    /// For universal applications, you can use this property to tailor the behavior 
    /// of your application for a specific type of device. 
    /// For example, iPhone and iPad devices have different screen sizes, so you might 
    /// want to create different views and controls based on the type of the current device.
    /// </summary>
    public ISN_UIUserInterfaceIdiom UserInterfaceIdiom {get;}

    /// <summary>
    /// An alphanumeric string that uniquely identifies a device to the app’s vendor.
    /// 
    /// The value of this property is the same for apps that come from the same vendor 
    /// running on the same device. 
    /// A different value is returned for apps on the same device that come from different
    /// vendors, and for apps on different devices regardless of vendor.
    /// Normally, the vendor is determined by data provided by the App Store. If the app was
    /// not installed from the app store (such as enterprise apps and apps still in development), 
    /// then a vendor identifier is calculated based on the app’s bundle ID. 
    /// The bundle ID is assumed to be in reverse-DNS format.
    /// </summary>
    public string IdentifierForVendor {get;}

    /// <summary>
    /// The current major version number of the operating system.
    /// Example: 11
    /// </summary>
    public int MajorIOSVersion {get;}
}

ISN_UIApplicationDelegate

namespace SA.IOSNative.UIKit
...

/// <summary>
/// A set of methods that are called in response to important events in the lifetime of your app.
/// </summary>
public class ISN_UIApplicationDelegate : ISN_Singleton<ISN_UIApplicationDelegate>
{
    /// <summary>
    /// Called when the user selects a Home screen quick action for your app, 
    /// except when you’ve intercepted the interaction in a launch method.
    /// </summary>
    public SA_iEvent<ISN_UIApplicationShortcutItem> PerformActionForShortcutItem {get;}

    /// <summary>
    /// In case application was launched using Home screen quick action,
    /// This method will return instance of <see cref="ISN_UIApplicationShortcutItem"/>,
    /// with the correspondent item type.
    /// <c>null</c> if app wasn't launched using Home screen quick action.
    /// </summary>
    public ISN_UIApplicationShortcutItem GetAppOpenShortcutItem()

    //--------------------------------------
    //  Universal Links (Deeplinking)
    //--------------------------------------

    /// <summary>
    /// Tells the delegate that the data for continuing an activity is available.
    /// 
    /// The app calls this method when it receives data associated with a user activity. 
    /// For example, when the user uses Handoff to transfer an activity from a different device.
    /// Use this method to update your iOS app so that the user can continue the activity
    /// from where they left off. 
    /// </summary>
    public SA_iEvent<string> ContinueUserActivity {get;}

    /// <summary>
    /// If applicaion was launched usning deeplinking, 
    /// method will return URL that was used to launch the app. 
    /// An Empty string will be returns otherwise. 
    /// </summary>
    public string GetLunchUniversalLink();

    /// <summary>
    /// Asks the delegate to open a resource specified by a URL
    /// 
    /// If a URL arrives while your app is suspended or running in the background, 
    /// the system moves your app to the foreground prior to calling this method.
    /// </summary>
    public SA_iEvent<string> OpenURL {get;}

    /// <summary>
    /// If your app has received reques to open spesific URL, 
    /// the URL will be saved and always accessible by this method. 
    /// Methods will return an empty string if no open URL was received
    /// </summary>
    /// <returns>The lunch URL.</returns>
    public string GetLunchURL();

    //--------------------------------------
    // Application System Events
    //--------------------------------------


    /// <summary>
    /// Tells the delegate that the app is now in the background.
    /// Use this method to release shared resources, invalidate timers, 
    /// and store enough app state information to restore your app to its current state 
    /// in case it is terminated later. 
    /// You should also disable updates to your app’s user interface and avoid using 
    /// some types of shared system resources 
    /// (such as the user’s contacts database). It is also imperative that you avoid using 
    /// OpenGL ES in the background.
    /// Your implementation of this method has approximately five seconds to perform any tasks and return.
    /// </summary>
    public SA_iEvent ApplicationDidEnterBackground {get;}

    /// <summary>
    /// Tells the delegate that the app is about to enter the foreground.
    /// 
    /// In iOS 4.0 and later, this method is called as part of the transition from the 
    /// background to the active state. 
    /// You can use this method to undo many of the changes you made to your app upon 
    /// entering the background. 
    /// The call to this method is invariably followed by a call to the 
    /// <see cref="ApplicationDidBecomeActive"/> method, 
    /// which then moves the app from the inactive to the active state.
    /// </summary>
    public SA_iEvent ApplicationWillEnterForeground {get;}

    /// <summary>
    /// Tells the delegate that the app has become active.
    /// 
    /// This method is called to let your app know that it moved from the inactive to active state. 
    /// This can occur because your app was launched by the user or the system. 
    /// Apps can also return to the active state if the user chooses to ignore an interruption 
    /// (such as an incoming phone call or SMS message) that sent the app temporarily 
    /// to the inactive state.
    /// You should use this method to restart any tasks that were paused (or not yet started)     
    /// while the app was inactive. 
    /// For example, you could use it to restart timers or throttle up OpenGL ES frame rates. 
    /// If your app was previously in the background, you could also use it to refresh 
    /// your app’s user interface.
    /// </summary>
    public SA_iEvent ApplicationDidBecomeActive {get;}


    /// <summary>
    /// Tells the delegate that the app is about to become inactive.
    /// 
    /// This method is called to let your app know that it is about to move from the 
    /// active to inactive state. 
    /// This can occur for certain types of temporary interruptions (such as an incoming 
    /// phone call or SMS message) 
    /// or when the user quits the app and it begins the transition to the background state. 
    /// An app in the inactive state continues to run but does not dispatch incoming 
    /// events to responders.
    /// You should use this method to pause ongoing tasks, disable timers, 
    /// and throttle down OpenGL ES frame rates.Games should use this method to pause the game.
    /// An app in the inactive state should do minimal work while it waits to transition 
    /// to either the active or background state.
    ///
    /// If your app has unsaved user data, you can save it here to ensure that it is not lost. 
    /// However, it is recommended that you save user data at appropriate points throughout 
    /// the execution of your app, usually in response to specific actions. 
    /// For example, save data when the user dismisses a data entry screen. 
    /// Do not rely on specific app state transitions to save all of your app’s critical data.
    /// </summary>
    public SA_iEvent ApplicationWillResignActive {get;}

    /// <summary>
    /// Tells the delegate when the app receives a memory warning from the system.
    /// 
    /// Your implementation of this method should free up as much memory as possible 
    /// by purging cached data objects that can be recreated (or reloaded from disk) later.
    /// 
    /// It is strongly recommended that you implement this method. 
    /// If your app does not release enough memory during low-memory conditions, the system may terminate it outright. 
    /// </summary>
    public SA_iEvent ApplicationDidReceiveMemoryWarning {get;}

    /// <summary>
    /// Tells the delegate when the app is about to terminate.
    /// 
    /// This method lets your app know that it is about to be terminated and purged from memory entirely. 
    /// You should use this method to perform any final clean-up tasks for your app, such as freeing shared resources, 
    /// saving user data, and invalidating timers. 
    /// Your implementation of this method has approximately five seconds to perform any tasks and return. 
    /// If the method does not return before time expires, the system may kill the process altogether.
    /// </summary>
    public SA_iEvent ApplicationWillTerminate {get;}
}

ISN_UIAlertController

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// An object that displays an alert message to the user.
    /// Use this class to configure alerts and action sheets with the message that you want to display and the actions from which to choose. 
    /// After configuring the alert controller with the actions and style you want, present it using the <see cref="Present"/> method. 
    /// UIKit displays alerts and action sheets modally over your app's content.
    /// 
    /// In addition to displaying a message to a user, you can associate actions with your alert controller to give the user a way to respond. 
    /// For each action you add using the <see cref="AddAction"/> method, 
    /// the alert controller configures a button with the action details. 
    /// When the user taps that action, the alert controller executes the block you provided when creating the action object. 
    /// </summary>
    public class ISN_UIAlertController 
    {
        public ISN_UIAlertController(string title, string message, ISN_UIAlertControllerStyle preferredStyle);

        /// <summary>
        /// Presents a view controller modally.
        /// </summary>
        public void Present();

        /// <summary>
        /// Dismiss view controller.
        /// </summary>
        public void Dismiss();

        /// <summary>
        /// Attaches an action object to the alert or action sheet.
        /// If your alert has multiple actions, the order in which you add those actions determines their order in the resulting alert or action sheet.
        /// </summary>
        /// <param name="action">
        /// The action object to display as part of the alert. Actions are displayed as buttons in the alert. 
        /// The action object provides the button text and the action to be performed when that button is tapped.
        /// </param>
        public void AddAction(ISN_UIAlertAction action);

        /// <summary>
        /// The preferred action for the user to take from an alert.
        /// 
        /// The preferred action is relevant for the <see cref="ISN_UIAlertControllerStyle.Alert"/> style only; 
        /// it is not used by action sheets. 
        /// When you specify a preferred action, the alert controller highlights the text of that action to give it emphasis. 
        /// (If the alert also contains a cancel button, the preferred action receives the highlighting instead of the cancel button.) 
        /// If the iOS device is connected to a physical keyboard, pressing the Return key triggers the preferred action.
        /// 
        /// The action object you assign to this property must have already been added to the alert controller’s list of actions.
        /// Assigning an object to this property before adding it with the <see cref="AddAction"/> method is a programmer error.
        /// The default value of this property is nil.
        /// </summary>
        public ISN_UIAlertAction PreferredAction {get;set;}

        /// <summary>
        /// Gets the unique alert identifier.
        /// </summary>
        public int Id {get;}

        /// <summary>
        /// The title of the alert.
        /// 
        /// The title string is displayed prominently in the alert or action sheet. 
        /// You should use this string to get the user’s attention and communicate the reason for displaying the alert.
        /// </summary>
        public string Title {get;}

        /// <summary>
        /// Descriptive text that provides more details about the reason for the alert.
        /// 
        /// The message string is displayed below the title string and is less prominent. 
        /// Use this string to provide additional context about the reason for the alert or about the actions that the user might take.
        /// </summary>
        public string Message {get;}

        /// <summary>
        /// The style of the alert controller.
        /// </summary>
        public ISN_UIAlertControllerStyle PreferredStyle {get;}

        /// <summary>
        /// The actions that the user can take in response to the alert or action sheet.
        /// 
        /// The actions are in the order in which you added them to the alert controller. 
        /// This order also corresponds to the order in which they are displayed in the alert or action sheet. 
        /// The second action in the array is displayed below the first, the third is displayed below the second, and so on.
        /// </summary>
        public List<ISN_UIAlertAction> Actions {get;set;}
    }
}

ISN_UIAlertAction

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// An action that can be taken when the user taps a button in an alert.
    /// </summary>
    public class ISN_UIAlertAction 
    {
        /// <summary>
        /// Create and return an action with the specified title and behavior.
        /// </summary>
        /// <param name="title">
        /// The text to use for the button title. The value you specify should be localized for the user’s current language. 
        /// This parameter must not be nil, except in a tvOS app where a nil title may be used with <see cref="ISN_UIAlertActionStyle.Cancel"/>..
        /// </param>
        /// <param name="style">
        /// Additional styling information to apply to the button. 
        /// Use the style information to convey the type of action that is performed by the button. 
        /// For a list of possible values, see the constants in <see cref="ISN_UIAlertActionStyle"/>.
        /// </param>
        /// <param name="action">A block to execute when the user selects the action.</param>
        public ISN_UIAlertAction(string title, ISN_UIAlertActionStyle style, Action action);

        /// <summary>
        /// Gets the unique action identifier.
        /// </summary>
        public int Id {get;}

        /// <summary>
        /// The title of the action’s button.
        /// </summary>
        public string Title {get;}

        /// <summary>
        /// The style that is applied to the action’s button.
        /// </summary>
        public ISN_UIAlertActionStyle Style {get;}

        /// <summary>
        /// A Boolean value indicating whether the action is currently enabled.
        /// </summary>
        public bool Enabled {get;set;}

        /// <summary>
        /// True if action is preffered.
        /// </summary>
        public bool Preffered {get;}

        public void MakePreffered();

        public void Invoke();
    }
}

ISN_UIUrlType

namespace SA.IOSNative.UIKit
{
    public class ISN_UIUrlType 
    {
        public string Identifier = string.Empty;

        public List<string> Schemes = new List<string>();

        public ISN_UIUrlType(string identifier);

        public void AddSchemes(string schemes);
    }
}

ISN_UIPickerControllerResult

namespace SA.IOSNative.UIKit
{
    public class ISN_UIPickerControllerResult : SA_Result
    {
        public ISN_UIPickerControllerResult(SA_Error error):base(error) {}

        /// <summary>
        /// Selected Video path. Empty if user has selected photo instead.
        /// </summary>
        public string VideoPath {get;}

        /// <summary>
        /// Gets the selected texture.
        /// Value can be <c>null</c> in case user canceled selection, or picked video instead.
        /// </summary>
        /// <value>The texture.</value>
        public Texture2D Image {get;}
    }
}

ISN_UIPickerControllerRequest

namespace SA.IOSNative.UIKit
{
    public class ISN_UIPickerControllerRequest 
    {
        public List<string> m_mediaTypes;
        public ISN_UIImagePickerControllerSourceType m_sourceType;
        public bool m_allowsEditing;

        public float m_imageCompressionRate;
        public int m_maxImageSize;
        public ISN_UIImageCompressionFormat m_encodingType;
    }
}

ISN_UIAvailableMediaTypes

namespace SA.IOSNative.UIKit
{
    public class ISN_UIAvailableMediaTypes {
        /// <summary>
        /// Gets the types.
        /// </summary>
        /// <value>The types.</value>
        public List<string> Types {get;}
    }
}

ISN_UIApplicationShortcutItem

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// An application shortcut item, 
    /// also called a Home screen dynamic quick action, that specifies a user-initiated action for your app.
    /// </summary>
    public class ISN_UIApplicationShortcutItem 
    {
        public ISN_UIApplicationShortcutItem(string type);

        /// <summary>
        /// A required, app-specific string that you employ to identify the type of quick action to perform.
        /// </summary>
        /// <value>The type.</value>
        public string Type {get;set;}

        /// <summary>
        /// The quick action title
        /// </summary>
        public string Title {get;set;}

        /// <summary>
        /// The quick action title
        /// </summary>
        public string Subtitle {get;set;}
    }
}

ISN_UIUserNotificationType

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// Constants indicating how the app alerts the user when a local or push notification arrives.
    /// </summary>
    public enum ISN_UIUserNotificationType
    {
       None = 0,       // the application may not present any UI upon a notification being received
       Badge = 1 << 0, // the application may badge its icon upon a notification being received
       Sound = 1 << 1, // the application may play a sound upon a notification being received
       Alert = 1 << 2, // the application may display an alert upon a notification being received
    }
}

ISN_UIUserInterfaceIdiom

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// The type of interface that should be used on the current device
    /// </summary>
    public enum ISN_UIUserInterfaceIdiom 
    {
        Unspecified = -1,
        Phone = 0, // iPhone and iPod touch style UI
        Pad = 1, // iPad style UI
        TV = 2, // Apple TV style UI
        CarPlay = 3 // CarPlay style UI
    }
}

ISN_UIMediaType

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// Contant's of supported MediaType's by <see cref="ISN_UIImagePickerController"/>
    /// </summary>
    public class ISN_UIMediaType
    {
        public const string IMAGE = "public.image";
        public const string MOVIE = "public.movie";
    }
}

ISN_UIImagePickerControllerSourceType

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// The source to use when picking an image or when determining available media types.
    /// </summary>
    public enum ISN_UIImagePickerControllerSourceType
    {
        PhotoLibrary,
        Camera,
        Album
    }
}

ISN_UIImageCompressionFormat

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// Image compression fromat options for <see cref="ISN_UIImagePickerController"/>
    /// </summary>
    public enum ISN_UIImageCompressionFormat
    {
        PNG = 0,
        JPEG = 1
    }
}

ISN_UIAlertControllerStyle

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// Constants indicating the type of alert to display.
    /// </summary>
    public enum ISN_UIAlertControllerStyle
    {
        ActionSheet, //An action sheet displayed in the context of the view controller that presented it.
        Alert   //An alert displayed modally for the app.
    }
}

ISN_UIAlertActionStyle

namespace SA.IOSNative.UIKit
{
    /// <summary>
    /// Styles to apply to action buttons in an alert.
    /// </summary>
    public enum ISN_UIAlertActionStyle 
    {
        Default, //Apply the default style to the action’s button.
        Cancel,  //Apply a style that indicates the action cancels the operation and leaves things unchanged.
        Destructive //Apply a style that indicates the action might change or delete data.
    }
}