API Reference

Controllers

ISN_UNUserNotificationCenter

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// The central object for managing notification-related activities for your app or app extension.
/// </summary>
public static class ISN_UNUserNotificationCenter 
{
    /// <summary>
    /// Requests authorization to interact with the user when local and remote notifications arrive.
    /// 
    /// If the local or remote notifications of your app or app extension interact with the user in any way, 
    /// you must call this method to request authorization for those interactions. 
    /// The first time your app ever calls the method, the system prompts the user to authorize the requested options. 
    /// The user may respond by granting or denying authorization, 
    /// and the system stores the user’s response so that subsequent calls to this method do not prompt the user again. 
    /// The user may change the allowed interactions at any time. Use the <see cref="GetNotificationSettings"/> method 
    /// to determine what your app is allowed to do.
    /// 
    /// After determining the authorization status, the user notification center object executes the block you provide in the <see cref="callback"/> parameter. 
    /// Use that block to make any adjustments in your app. 
    /// For example, if authorization was denied, you might notify a remote notification server not to send notifications to the user’s device.
    /// 
    /// Always call this method before scheduling any local notifications and before registering with the Apple Push Notification Service. 
    /// Typically, you call this method at launch time when configuring your app's notification support. 
    /// However, you may call it at another time in your app's life cycle, providing that you call it before performing any other notification-related tasks.
    /// </summary>
    /// <param name="options">
    /// The authorization options your app is requesting. You may combine the available constants to request authorization for multiple items. 
    /// Request only the authorization options that you plan to use. For a list of possible values, see <see cref="ISN_UNAuthorizationOptions"/>
    /// </param>
    /// <param name="callback">The block to execute asynchronously with the results.</param>
    public static void RequestAuthorization(int options, Action<SA_Result> callback);

    /// <summary>
    /// Requests the notification settings for this app.
    /// 
    /// Use this method to determine the specific notification-related features that your app is allowed to use. 
    /// When the user authorizes your app to post notifications, the system authorizes your app with a set of default notification-related settings. 
    /// The user may further customize those settings to enable or disable specific capabilities. 
    /// For example, the user might disable the playing of sounds in conjunction with your notifications. 
    /// You can use the settings in the provided object to adjust the content of any scheduled notifications.
    /// </summary>
    /// <param name="callback">The block to execute asynchronously with the results.</param>
    public static void GetNotificationSettings(Action<ISN_UNNotificationSettings> callback);

    /// <summary>
    /// Schedules a local notification for delivery.
    /// 
    /// This method schedules local notifications only; 
    /// You cannot use it to schedule the delivery of push notifications. 
    /// The notification is delivered when the trigger condition in the request parameter is met. 
    /// If the request does not contain a <see cref="ISN_UNNotificationTrigger"/> object, the notification is delivered right away.
    /// 
    /// You may call this method from any thread of your app.
    /// </summary>
    /// <param name="request">The notification request to schedule.This parameter must not be <c>null</c></param>
    /// <param name="callback">The block to execute with the results.</param>
    public static void AddNotificationRequest(ISN_UNNotificationRequest request, Action<SA_Result> callback);

    /// <summary>
    /// Unschedules all pending notification requests.
    /// This method executes asynchronously, removing all pending notification requests on a secondary thread.
    /// </summary>
    public static void RemoveAllPendingNotificationRequests();

    /// <summary>
    /// Unschedules the specified notification requests.
    /// This method executes asynchronously, removing the pending notification requests on a secondary thread.
    /// </summary>
    /// <param name="requests">
    /// An array of <see cref="ISN_UNNotificationRequest"/> objects, 
    /// each of which contains the identifier of an active notification request object. 
    /// If the identifier belongs to a non repeating request whose notification has already been delivered, 
    /// this method ignores the identifier.
    /// </param>
    public static void RemovePendingNotificationRequests(params ISN_UNNotificationRequest[] requests);

    /// <summary>
    /// Unschedules the specified notification requests.
    /// This method executes asynchronously, removing the pending notification requests on a secondary thread.
    /// </summary>
    /// <param name="identifiers">
    /// An array of <see cref="string"/> objects, 
    /// each of which contains the identifier of an active notification request object. 
    /// If the identifier belongs to a non repeating request whose notification has already been delivered, 
    /// this method ignores the identifier.
    /// </param>
    public static void RemovePendingNotificationRequests(params string[] identifiers);

    /// <summary>
    /// Returns a list of all notification requests that are scheduled and waiting to be delivered.
    /// 
    /// This method executes asynchronously, returning immediately 
    /// and executing the provided block on a secondary thread when the results are available.
    /// </summary>
    /// <param name="callback">A block for processing notification requests.</param>
    public static void GetPendingNotificationRequests(Action<List<ISN_UNNotificationRequest>> callback);

    /// <summary>
    /// Provides you with a list of the app’s notifications that are still displayed in Notification Center.
    /// 
    /// This method executes asynchronously, returning immediately 
    /// and executing the provided block on a background thread when the results become available.
    /// </summary>
    /// <param name="callback">The block to execute with the results.</param>
    public static void GetDeliveredNotifications(Action<List<ISN_UNNotification>> callback);
  
    /// <summary>
    /// Removes all of the app’s notifications from Notification Center.
    /// 
    /// Use this method to remove all of your app’s notifications from Notification Center. 
    /// The method executes asynchronously, returning immediately 
    /// and removing the identifiers on a background thread.
    /// </summary>
    public static void RemoveAllDeliveredNotifications();

    /// <summary>
    /// Removes the specified notifications from Notification Center.
    /// 
    /// Use this method to selectively remove notifications that you no longer want displayed in Notification Center. 
    /// The method executes asynchronously, returning immediately and removing the identifiers on a background thread.
    /// </summary>
    /// <param name="identifiers">
    /// An array of <see cref="string"/> objects, each of which corresponds to the identifier 
    /// associated with a notification request object. 
    /// This method ignores the <c>identifiers</c> of request objects whose notifications 
    /// are not currently displayed in Notification Center.
    /// </param>
    public static void RemoveDeliveredNotifications(params string[] identifiers);
}

ISN_UNUserNotificationCenterDelegate

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// The interface for handling notification-related interactions in your app or app extension.
/// 
/// The <see cref="ISN_UNUserNotificationCenterDelegate"/> defines events for responding to actionable notifications 
/// and receiving notifications while your app is in the foreground. 
/// The user notification center calls methods of this delegate at appropriate times to deliver information.
/// 
/// You must subscribe to this object events as soon as possible. 
/// However, delegate may already receive action while app was luanching. For example if user has launched the app
/// by clicking on notifications. You may check <see cref="LastReceivedResponse"/> to find out of app was launched
/// using the notification. If Property is null after your app is launched it means that application was laucnhed
/// wihout interaction with the notification object.
/// 
/// </summary>
public static class ISN_UNUserNotificationCenterDelegate
{
    /// <summary>
    /// Called when a notification is delivered to a foreground app.
    /// 
    /// If your app is in the foreground when a notification arrives, 
    /// the notification center calls this method to deliver the notification directly to your app. 
    /// If you implement this method, you can take whatever actions are necessary to process the notification 
    /// and update your app. 
    /// User will not be alreated by a system;
    /// </summary>
    public static SA_iEvent<ISN_UNNotification> WillPresentNotification {get;}

    /// <summary>
    /// Called to let your app know which action was selected by the user for a given notification.
    /// 
    /// Use this method to perform the tasks associated with your app’s custom actions. 
    /// When the user responds to a notification, the system calls this method with the results. 
    /// You use this method to perform the task associated with that action, if at all. 
    /// 
    /// If you do not subscribe this event, your app never responds to custom actions.
    /// </summary>
    public static SA_iEvent<ISN_UNNotificationResponse> DidReceiveNotificationResponse {get;}

    /// <summary>
    /// Contains last received <see cref="ISN_UNNotificationResponse"/> object by delegate.
    /// 
    /// You must subscribe to this object events as soon as possible. 
    /// However, delegate may already receive action while app was luanching. For example if user has launched the app
    /// by clicking on notifications. You may check <see cref="LastReceivedResponse"/> to find out of app was launched
    /// using the notification. If Property is null after your app is launched it means that application was laucnhed
    /// wihout interaction with the notification object.
    /// </summary>
    public static ISN_UNNotificationResponse LastReceivedResponse { get;}
}

Enums

ISN_UNAlertStyle

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// Constants indicating the types of alerts that can be displayed to the user.
/// </summary>
public enum ISN_UNAlertStyle 
{
    //No alerts. Alerts are not displayed for the app.
    None = 0,

    //Banner alerts. Alerts are displayed as a slide-down banner. 
    //Banners appear for a short time and then disappear automatically if the user does nothing.
    Banner,

    //Modal alerts. Alerts are displayed in a modal window that must be dismissed explicitly by the user.
    Alert,
}

ISN_UNAuthorizationOptions

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// Constants for requesting authorization to interact with the user.
/// </summary>
public static class ISN_UNAuthorizationOptions 
{
    //The ability to update the app’s badge.
    public const int Badge = (1 << 0);

    //The ability to play sounds.
    public const int Sound = (1 << 1);

    //The ability to display alerts.
    public const int Alert = (1 << 2);

    //The ability to display notifications in a CarPlay environment.
    public const int CarPlay = (1 << 3);
}

ISN_UNAuthorizationStatus

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// Constants indicating whether the app is allowed to schedule notifications.
/// </summary>
public enum ISN_UNAuthorizationStatus 
{
    // The user has not yet made a choice regarding whether the application may post user notifications.
    NotDetermined = 0,

    // The application is not authorized to post user notifications.
    Denied,

    // The application is authorized to post user notifications.
    Authorized
}

ISN_UNNotificationStatus

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// Constants indicating the current status of a notification setting.
/// </summary>
public enum ISN_UNNotificationStatus 
{
    // The application does not support this notification type
    NotSupported = 0,

    // The notification setting is turned off.
    Disabled,

    // The notification setting is turned on.
    Enabled,
}

ISN_UNNotificationTriggerType

namespace SA.IOSNative.UserNotifications
***
public enum ISN_UNNotificationTriggerType
{
    TimeInterval,
    Calendar,
    Location,
    PushNotification
}

ISN_UNShowPreviewsSetting

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// Constants indicating the types of alerts that can be displayed to the user.
/// </summary>
public enum ISN_UNShowPreviewsSetting 
{
    // Notification previews are always shown.
    Always,

    // Notifications previews are only shown when authenticated.
   WhenAuthenticated,

    // Notifications previews are never shown.
    Never
}

Templates

ISN_UNNotification

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// The data for a delivered notification.
/// 
/// A <see cref="ISN_UNNotification"/> object represents a local or remote notification 
/// that has been delivered to your app. 
/// A notification object consists of the initial notification request 
/// and the date on which the notification was delivered. 
/// The notification request includes the content of the notification 
/// and the trigger condition that caused it to be delivered.
/// 
/// You do not create instances of this class directly. 
/// Instead, the <see cref="ISN_UNUserNotificationCenter"/> object maintains the list of notification objects 
/// whose contents have been delivered to the user. 
/// Use the <see cref="ISN_UNUserNotificationCenter.GetDeliveredNotifications"/> method to retrieve 
/// those notification objects.
/// </summary>
public class ISN_UNNotification 
{
    /// <summary>
    /// The originating notification request.
    /// 
    /// For local notifications, the request object is a copy of the one you originally configured. 
    /// For remote notifications, the request object is synthesized from information received from the APNS server.
    /// </summary>
    public ISN_UNNotificationRequest Request {get;}

    /// <summary>
    /// The delivery date of the notification.
    /// This date is displayed to the user in Notification Center.
    /// </summary>
    public DateTime Date {get;}
}

ISN_UNNotificationContent

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// The content of a local or remote notification.
/// </summary>
public class ISN_UNNotificationContent
{
    /// <summary>
    /// A short description of the reason for the alert.
    /// 
    /// When a title is present, the system attempts to display a notification alert. 
    /// Apps must be authorized to display alerts.
    /// 
    /// Title strings should be short, usually only a couple of words describing the reason for the notification.
    /// In watchOS, the title string is displayed as part of the short look notification interface,
    /// which has limited space.
    /// </summary>
    public string Title {get;set;}

    /// <summary>
    /// A secondary description of the reason for the alert.
    /// 
    /// Subtitles offer additional context in cases where the title alone is not clear. 
    /// Subtitles are not displayed in all cases.
    /// </summary>
    public string Subtitle {get;set;}

    /// <summary>
    /// The message displayed in the notification alert.
    /// 
    /// Printf style escape characters are stripped from the string prior to display; 
    /// to include a percent symbol (%) in the message body, use two percent symbols (%%).
    /// </summary>
    public string Body {get;set;}

    /// <summary>
    /// The number to display as the app’s icon badge.
    /// 
    /// When the number in this property is 0, the system does not display a badge. 
    /// When the number is greater than 0, the system displays the badge with the specified number.
    /// </summary>
    public long Badge {get;set;}

    /// <summary>
    /// The sound to play when the notification is delivered.
    /// 
    /// Notifications can play a default sound or a custom sound. 
    /// For information on how to specify custom sounds for your notifications, 
    /// see <see cref="ISN_UNNotificationSound"/>.
    /// </summary>
    public ISN_UNNotificationSound Sound {get;set;}
   
    /// <summary>
    /// A custom developer defined serializable object associated with the notification.
    /// 
    /// The object will be serialized with <see cref="JsonUtility.ToJson"/>. 
    /// Make sure you are using appropriate object that can be serialized.
    /// </summary>
    /// <param name="userInfo">Serializable object.</param>
    public void SetUserInfo(object userInfo);

    /// <summary>
    /// Get's custom developer defined serializable object associated with the notification.
    /// The object will be deserialized with <see cref="JsonUtility.FromJson"/>. 
    /// Make sure you are using appropriate object that can be deserialized.
    /// </summary>
    public T GetUserInfo<T>();
}

ISN_UNNotificationRequest

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// An object you use to specify a notification’s content and the condition that triggers its delivery.
/// </summary>
public class ISN_UNNotificationRequest 
{
    /// <summary>
    /// Creates and returns a local notification request object.
    /// 
    /// Use this method when you want to schedule the delivery of a local notification. 
    /// This method creates the request object that you subsequently pass to the 
    /// <see cref="ISN_UNUserNotificationCenter.AddNotificationRequest"/> method.
    /// 
    /// The system uses the identifier parameter to determine how to handle the request:
    ///  * If you provide a unique identifier, the system creates a new notification.
    ///  * If the identifier matches a previously delivered notification, the system alerts the user again, 
    /// replaces the old notification with the new one, and places the new notification at the top of the list.
    ///  * If the identifier matches a pending request, the new request replaces the pending request.
    /// </summary>
    /// <param name="identifier">
    /// An identifier for the request; this parameter must not be <c>null</c>. 
    /// You can use this identifier to cancel the request if it is still pending 
    /// <see cref="ISN_UNUserNotificationCenter.RemovePendingNotificationRequests"/> method.
    /// </param>
    /// <param name="content">
    /// The content of the notification. This parameter must not be <c>null</c>. 
    /// </param>
    /// <param name="trigger">
    /// The condition that causes the notification to be delivered. Specify <c>null</c> to deliver the notification right away.
    /// </param>
    public ISN_UNNotificationRequest(string identifier, ISN_UNNotificationContent content, ISN_UNNotificationTrigger trigger );

    /// <summary>
    /// The unique identifier for this notification request.
    /// 
    /// Use this string to identify notifications in your app. 
    /// For example, you can pass this string to the <see cref="ISN_UNUserNotificationCenter.RemovePendingNotificationRequests()"/> 
    /// method to cancel a previously scheduled notification.
    /// 
    /// If you use the same identifier when scheduling a new notification, 
    /// the system removes the previously scheduled notification with that identifier and replaces it with the new one.
    /// </summary>
    public string Identifier {get;}

    /// <summary>
    /// The content associated with the notification.
    /// 
    /// Use this property to access the contents of the notification. 
    /// The content object contains the badge information, sound to be played, 
    /// or alert text to be displayed to the user, in addition to the notification’s thread identifier.
    /// </summary>
    public ISN_UNNotificationContent Content {get;set;}

    /// <summary>
    /// The conditions that trigger the delivery of the notification.
    /// 
    /// For notifications that have already been delivered, use this property 
    /// to determine what caused the delivery to occur.
    /// </summary>
    public ISN_UNNotificationTrigger Trigger {get;set;}
}

ISN_UNNotificationResponse

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// The user’s response to an actionable notification.
/// 
/// When the user interacts with a delivered notification, 
/// the system delivers a <see cref="ISN_UNNotificationResponse"/> object to your app 
/// so that you can process the response. 
/// Users can interact with delivered notifications in many ways. 
/// If the notification’s category had associated action buttons, they can select one of those buttons. 
/// Users can also dismiss the notification without selecting one of your actions and they can open your app. 
/// A response object tells you which option that the user selected.
/// 
/// You do not create instances of this class yourself. 
/// Instead, the notification center object creates instances and delivers them 
/// to the <see cref="ISN_UNUserNotificationCenterDelegate"/>. 
/// You use that method to extract any needed information from the response objects and take appropriate actions. 
/// For more information about, see the <see cref="ISN_UNUserNotificationCenterDelegate"/>.
/// </summary>
public class ISN_UNNotificationResponse
{
    /// <summary>
    /// The notification to which the user responded.
    /// </summary>
    public ISN_UNNotification Notification {get;}

    //TODO: define UNNotificationDismissActionIdentifier & UNNotificationDefaultActionIdentifier

    /// <summary>
    /// The identifier for the action that the user selected.
    /// 
    /// This parameter may contain one the identifier of one of your <see cref="UNNotificationAction"/> objects
    /// or it may contain a system-defined identifier. 
    /// The system defined identifiers are UNNotificationDefaultActionIdentifier 
    /// and UNNotificationDismissActionIdentifier, which indicate that the user opened the app 
    /// or dismissed the notification without any further actions.
    /// 
    /// For more information about defining custom actions, see <see cref="UNNotificationAction"/>.
    /// </summary>
    public string ActionIdentifier {get;}
}

ISN_UNNotificationSettings

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// The object for managing notification-related settings and the authorization status of your app
/// </summary>
public class ISN_UNNotificationSettings 
{
    //--------------------------------------
    // Getting Device Settings
    //--------------------------------------
    /// <summary>
    /// The authorization status indicating the app’s ability to interact with the user.
    /// </summary>
    public ISN_UNAuthorizationStatus AuthorizationStatus {get;}

    /// <summary>
    /// The setting that indicates whether your app’s notifications are displayed in Notification Center.
    /// Your app’s notifications appear in Notification Center by default, but the user may disable this setting later.
    /// </summary>
    public ISN_UNNotificationStatus NotificationCenterSetting {get;}


    /// <summary>
    /// The setting that indicates whether your app’s notifications appear onscreen when the device is locked.
    /// Even if the user disables lock screen notifications, your notifications may still appear onscreen when the device is unlocked.
    /// </summary>
    public ISN_UNNotificationStatus LockScreenSetting {get;}



    /// <summary>
    /// The setting that indicates whether your app’s notifications may be displayed in a CarPlay environment.
    /// </summary>
    public ISN_UNNotificationStatus CarPlaySetting {get;}

    //--------------------------------------
    // Getting User Notification Settings
    //--------------------------------------

    /// <summary>
    /// The authorization status for displaying alerts.
    /// </summary>
    public ISN_UNNotificationStatus AlertSetting {get;}

    /// <summary>
    /// The type of alert that the app may display when the device is unlocked.
    /// 
    /// When alerts are authorized, this property specifies the presentation style for alerts when the device is unlocked. 
    /// The user may choose to display alerts as automatically disappearing banners or as modal windows that require explicit dismissal. 
    /// The user may also choose not to display alerts at all.
    /// </summary>
    public ISN_UNAlertStyle AlertStyle {get;}

    /// <summary>
    /// The authorization status for badging your app’s icon.
    /// 
    /// When this setting is enabled, notifications may update the badge value displayed on top of the app’s icon. 
    /// The badge value is stored in the badge property of the UNNotificationContent object.
    /// </summary>
    public ISN_UNNotificationStatus BadgeSetting {get;}

    /// <summary>
    /// The authorization status for playing sounds for incoming notifications.
    /// 
    /// When this setting is enabled, notifications may play sounds upon delivery. 
    /// The sound to be played for the notification is stored in the sound property of the UNNotificationContent object.
    /// </summary>
    public ISN_UNNotificationStatus SoundSetting {get;}


    /// <summary>
    /// The setting for whether apps show a preview of the notification's content.
    /// </summary>
    public ISN_UNShowPreviewsSetting ShowPreviewsSetting {get;}
}

ISN_UNNotificationSound

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// A sound to be played when a notification is delivered.
/// </summary>
public class ISN_UNNotificationSound 
{
    public ISN_UNNotificationSound(string name);

    /// <summary>
    /// Sound file name
    /// </summary>
    /// <value>The name of the sound.</value>
    public string SoundName {get;}

    /// <summary>
    /// Returns an object representing the default sound for notifications.
    /// </summary>
    public static ISN_UNNotificationSound DefaultSound {get;}

    /// <summary>
    /// Creates and returns a notification sound object that plays the specified sound file.
    /// 
    /// Make sure you've added sounds file to the XCode project with IOS Deploy settings
    /// Stan's Assets -> IOS Deploy Pro -> Setting  and look for a files section
    /// 
    /// Also feel free to use another ways of adding sound ot the XCode project.
    /// Just keep in mind that file must be located in the current executable’s main bundle 
    /// or in the Library/Sounds directory of the current app container directory. 
    /// </summary>
    /// <param name="name">The name of the sound file to play. This file must be located in the current executable’s main bundle.</param>
    public static ISN_UNNotificationSound SoundNamed(string name);
}

Triggers

ISN_UNCalendarNotificationTrigger

namespace SA.IOSNative.UserNotifications
***
public class ISN_UNCalendarNotificationTrigger : ISN_UNNotificationTrigger
{
    /// <summary>
    /// Creates and returns a calendar trigger from the specified date components.
    /// </summary>
    /// <param name="dateComponents">
    /// The temporal information to use when constructing the trigger. 
    /// Provide only the date components that are relevant for your trigger.
    /// </param>
    /// <param name="repeats">
    /// Specify <c>false</c> to unschedule the notification after the trigger fires. 
    /// Specify <c>true</c> if you want the notification to be rescheduled after it fires.
    /// </param>
    public ISN_UNCalendarNotificationTrigger(ISN_NSDateComponents dateComponents, bool repeats);


    /// <summary>
    /// The date components used to construct this object
    /// Use this property to review the date components associated with this trigger.
    /// </summary>
    public ISN_NSDateComponents DateComponents {get;}
}

ISN_UNLocationNotificationTrigger

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// The geographic location that the user must reach to enable the delivery of a local notification.
/// </summary>
public class ISN_UNLocationNotificationTrigger : ISN_UNNotificationTrigger
{
    /// <summary>
    /// Creates and returns a location trigger for the specified region.
    /// </summary>
    /// <param name="region">
    /// The region to use for the trigger. 
    /// The trigger fires when the user’s device enters or leaves the region. 
    /// Use the region object to specify whether to deliver notifications on entry, on exit, or both.
    /// </param>
    /// <param name="repeats">
    /// Specify <c>false</c> to unschedule the notification after the trigger fires. 
    /// Specify <c>true</c> if you want the notification to be rescheduled after it fires.
    /// </param>
    public ISN_UNLocationNotificationTrigger(ISN_CLCircularRegion region, bool repeats);

    /// <summary>
    /// The region used to determine when the notification is sent.
    /// 
    /// Use the <see cref="notifyOnEntry"/> and <see cref="notifyOnExit"/> properties of this region 
    /// to specify whether notifications are sent when the user enters or exits the specified geographic area.
    /// </summary>
    public ISN_CLCircularRegion Region {get;set;}
}

ISN_UNNotificationTrigger

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// The common behavior for subclasses that trigger the delivery of a notification.
/// </summary>
public class ISN_UNNotificationTrigger 
{
    /// <summary>
    /// A Boolean value indicating whether the event repeats.
    /// 
    /// When this property is <c>False</c>, the notification is delivered once and then 
    /// the notification request is automatically unscheduled. 
    /// When this property is <c>True</c>, the notification request is not unscheduled automatically, 
    /// resulting in the notification being delivered each time the trigger condition is met.
    /// </summary>
    public bool Repeats {get;set;}

    /// <summary>
    /// The next date at which the trigger conditions will be met.
    /// Use this property to find out when a notification associated with this trigger will next be delivered.
    /// </summary>
    private DateTime NextTriggerDate {get;}


    /// <summary>
    /// Trigger type
    /// Trigger type is defined automatically and depends of constructor that was used 
    /// to create a <see cref="ISN_UNNotificationTrigger"/> object in a frist place
    /// </summary>
    public ISN_UNNotificationTriggerType Type {get;}
}

ISN_UNTimeIntervalNotificationTrigger

namespace SA.IOSNative.UserNotifications
***
/// <summary>
/// The time that must expire before the delivery of a local notification.
/// </summary>
public class ISN_UNTimeIntervalNotificationTrigger  : ISN_UNNotificationTrigger
{
    /// <summary>
    /// Creates and returns a time interval trigger from the specified time value.
    /// </summary>
    /// <param name="timeInterval">
    /// The time (in seconds) that must elapse before the trigger fires. This value must be greater than zero.
    /// </param>
    /// <param name="repeats">
    /// Specify <c>false</c> to unschedule the notification after the trigger fires. 
    /// Specify <c>true</c> if you want the notification to be rescheduled after it fires.
    /// </param>
    public ISN_UNTimeIntervalNotificationTrigger(long timeInterval, bool repeats);

    /// <summary>
    /// The time interval used to create the trigger.
    /// 
    /// This property contains the original time interval that you specified when creating the trigger object. T
    /// he value in this property is not updated as time counts down. 
    /// To find out when the trigger will fire next, 
    /// call the <see cref="NextTriggerDate"/> property.
    /// </summary>
    public long TimeInterval {get;set;}
}