diff --git a/packages/twitter/README.md b/packages/twitter/README.md
index 13572c13..1c021e91 100644
--- a/packages/twitter/README.md
+++ b/packages/twitter/README.md
@@ -19,32 +19,26 @@ Here is how callbacks would look like:
 
 ### iOS
 
-
-Configure Info.Plist like below, replace `consumerKey` tag with your own key:
-
 ```xml
 <key>CFBundleURLTypes</key>
 <array>
   <dict>
     <key>CFBundleURLSchemes</key>
     <array>
-      <string>twitterkit-<consumerKey></string>
+      <string>yourscheme></string>
     </array>
   </dict>
 </array>
-<key>LSApplicationQueriesSchemes</key>
-<array>
-    <string>twitter</string>
-    <string>twitterauth</string>
-</array>
 ```
 
 ```ts
 import { Twitter, TwitterSignIn } from '@nativescript/twitter';
 
-TwitterSignIn.init(TWITTER_COMSUMER_KEY, TWITTER_CONSUMER_SECRET);
+Twitter.callback = 'yourscheme://';
+
+Twitter.init(TWITTER_COMSUMER_KEY, TWITTER_CONSUMER_SECRET);
 
-Twitter.logIn()
+TwitterSignIn.logIn()
 	.then((session) => {
 		// session.authToken
 		// session.authTokenSecret
diff --git a/packages/twitter/index.android.ts b/packages/twitter/index.android.ts
index 40f957d3..b04d7191 100644
--- a/packages/twitter/index.android.ts
+++ b/packages/twitter/index.android.ts
@@ -63,6 +63,19 @@ export class TwitterUser implements ITwitterUser {
 	get android() {
 		return this.native;
 	}
+
+	toJSON() {
+		return {
+			formattedScreenName: this.formattedScreenName,
+			isProtected: this.isProtected,
+			isVerified: this.isVerified,
+			name: this.name,
+			profileImageUrl: this.profileImageUrl,
+			profileUrl: this.profileUrl,
+			screenName: this.screenName,
+			userId: this.userId
+		}
+	}
 }
 
 export class Twitter {
@@ -180,7 +193,7 @@ export class TwitterSignIn {
 			}
 
 			sessionManager.clearActiveSession();
-		} catch (e) {}
+		} catch (e) { }
 	}
 
 	static getCurrentUser() {
diff --git a/packages/twitter/index.d.ts b/packages/twitter/index.d.ts
index 70dbecd3..6a33858c 100644
--- a/packages/twitter/index.d.ts
+++ b/packages/twitter/index.d.ts
@@ -39,6 +39,7 @@ export declare class Session implements ISession {
 }
 
 export declare class Twitter {
+	static callback: string;
 	static init(consumerKey: string, consumerSecret: string);
 }
 
diff --git a/packages/twitter/index.ios.ts b/packages/twitter/index.ios.ts
index 7ce55ea5..dbeda664 100644
--- a/packages/twitter/index.ios.ts
+++ b/packages/twitter/index.ios.ts
@@ -1,3 +1,4 @@
+import { Application, Device } from '@nativescript/core';
 import { ISession, ITwitterUser } from './common';
 
 export class TwitterError extends Error {
@@ -14,9 +15,10 @@ export class TwitterError extends Error {
 }
 
 let appDelegateInitialized = false;
-let appDelegate: TwitterAppDelegateImpl;
-@NativeClass
+let appDelegate;
+
 @ObjCClass(UIApplicationDelegate)
+@NativeClass
 class TwitterAppDelegateImpl extends UIResponder implements UIApplicationDelegate {
 	static get sharedInstance() {
 		if (!appDelegate) {
@@ -26,14 +28,27 @@ class TwitterAppDelegateImpl extends UIResponder implements UIApplicationDelegat
 	}
 
 	applicationOpenURLOptions(app: UIApplication, url: NSURL, options: NSDictionary<string, any>): boolean {
-		return TWTRTwitter.sharedInstance().applicationOpenURLOptions(app, url, options);
+		TNSTwitter.handleOpenURL(url.absoluteString, Twitter.callback, false);
+		return true;
+	}
+
+}
+
+
+if (parseFloat(Device.sdkVersion) >= 13) {
+	(<any>TwitterAppDelegateImpl).prototype.applicationConfigurationForConnectingSceneSessionOptions = (application: UIApplication, connectingSceneSession: UISceneSession, options: UISceneConnectionOptions) => {
+		return UISceneConfiguration.configurationWithNameSessionRole(
+			"Default Configuration",
+			connectingSceneSession.role
+		)
 	}
 }
 
+
 export class TwitterUser implements ITwitterUser {
-	#native: TWTRUser;
-	static fromNative(user: TWTRUser) {
-		if (user instanceof TWTRUser) {
+	#native: any;
+	static fromNative(user: any) {
+		if (user) {
 			const usr = new TwitterUser();
 			usr.#native = user;
 			return usr;
@@ -42,15 +57,15 @@ export class TwitterUser implements ITwitterUser {
 	}
 
 	get formattedScreenName(): string {
-		return this.native.formattedScreenName;
+		return this.native.screen_name;
 	}
 
 	get isProtected(): boolean {
-		return this.native.isProtected;
+		return this.native.protected;
 	}
 
 	get isVerified(): boolean {
-		return this.isVerified;
+		return this.native.verified;
 	}
 
 	get name(): string {
@@ -58,19 +73,19 @@ export class TwitterUser implements ITwitterUser {
 	}
 
 	get profileImageUrl(): string {
-		return this.native.profileImageURL;
+		return this.native.profile_image_url_https;
 	}
 
 	get profileUrl(): string {
-		return this.native.profileURL?.absoluteString;
+		return this.native.url;
 	}
 
 	get screenName(): string {
-		return this.native.screenName;
+		return this.native.screen_name;
 	}
 
 	get userId(): string {
-		return this.native.userID;
+		return this.native.id_str;
 	}
 
 	get native() {
@@ -80,12 +95,26 @@ export class TwitterUser implements ITwitterUser {
 	get ios() {
 		return this.native;
 	}
+
+
+	toJSON() {
+		return {
+			formattedScreenName: this.formattedScreenName,
+			isProtected: this.isProtected,
+			isVerified: this.isVerified,
+			name: this.name,
+			profileImageUrl: this.profileImageUrl,
+			profileUrl: this.profileUrl,
+			screenName: this.screenName,
+			userId: this.userId
+		}
+	}
 }
 
 export class Session implements ISession {
-	#native: TWTRSession;
-	static fromNative(ts: TWTRSession) {
-		if (ts instanceof TWTRSession) {
+	#native: any;
+	static fromNative(ts) {
+		if (ts) {
 			const session = new Session();
 			session.#native = ts;
 			return session;
@@ -117,9 +146,12 @@ export class Session implements ISession {
 	}
 }
 
+
 export class Twitter {
+	static _twitter: TNSTwitter;
+	static callback: string;
 	static init(consumerKey: string, consumerSecret: string) {
-		TWTRTwitter.sharedInstance().startWithConsumerKeyConsumerSecret(consumerKey, consumerSecret);
+		this._twitter = TNSTwitter.alloc().init(consumerKey, consumerSecret);
 
 		if (!appDelegateInitialized) {
 			GULAppDelegateSwizzler.proxyOriginalDelegate();
@@ -132,38 +164,79 @@ export class Twitter {
 export class TwitterSignIn {
 	static logIn() {
 		return new Promise((resolve, reject) => {
-			TWTRTwitter.sharedInstance().logInWithCompletion((session, error) => {
-				if (session) {
-					resolve(Session.fromNative(session));
+			Twitter._twitter.authorizeWithBrowser(this.topViewController, Twitter.callback, (user, error) => {
+				if (user) {
+					try {
+						resolve(Session.fromNative(JSON.parse(user)));
+					} catch (e) {
+						reject(TwitterError.fromNative(e));
+					}
 				} else {
 					reject(TwitterError.fromNative(error));
 				}
-			});
+			})
 		});
 	}
-	static logOut() {
-		const store = TWTRTwitter.sharedInstance().sessionStore;
-		if (store) {
-			const userId = store.session()?.userID;
-			store.logOutUserID?.(userId);
-		}
-	}
+
+	static logOut() { }
 
 	static getCurrentUser(): Promise<TwitterUser> {
 		return new Promise((resolve, reject) => {
-			const store = TWTRTwitter.sharedInstance().sessionStore;
-			if (store) {
-				const userId = store.session()?.userID || '';
-				TWTRAPIClient.clientWithCurrentUser().loadUserWithIDCompletion(userId, (user, error) => {
-					if (error) {
-						reject(TwitterError.fromNative(error));
-					} else {
-						resolve(TwitterUser.fromNative(user));
+			Twitter._twitter.verifyUser(false, false, true, (user, error) => {
+				if (error) {
+					reject(TwitterError.fromNative(error));
+				} else {
+					try {
+						resolve(TwitterUser.fromNative(JSON.parse(user)));
+					} catch (e) {
+						reject(TwitterError.fromNative(e));
 					}
-				});
-			} else {
-				resolve(null);
-			}
+
+				}
+			})
 		});
 	}
+
+
+
+	private static get topViewController(): UIViewController | undefined {
+		const root = this.rootViewController;
+		if (!root) {
+			return undefined;
+		}
+		return this.findTopViewController(root);
+	}
+
+	private static get rootViewController(): UIViewController | undefined {
+		const keyWindow = UIApplication.sharedApplication.keyWindow;
+		return keyWindow ? keyWindow.rootViewController : undefined;
+	}
+
+	private static findTopViewController(root: UIViewController): UIViewController | undefined {
+		const presented = root.presentedViewController;
+		if (presented != null) {
+			return this.findTopViewController(presented);
+		}
+		if (root instanceof UISplitViewController) {
+			const last = root.viewControllers.lastObject;
+			if (last == null) {
+				return root;
+			}
+			return this.findTopViewController(last);
+		} else if (root instanceof UINavigationController) {
+			const top = root.topViewController;
+			if (top == null) {
+				return root;
+			}
+			return this.findTopViewController(top);
+		} else if (root instanceof UITabBarController) {
+			const selected = root.selectedViewController;
+			if (selected == null) {
+				return root;
+			}
+			return this.findTopViewController(selected);
+		} else {
+			return root;
+		}
+	}
 }
diff --git a/packages/twitter/package.json b/packages/twitter/package.json
index 44b3f34c..e10c821b 100644
--- a/packages/twitter/package.json
+++ b/packages/twitter/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@nativescript/twitter",
-  "version": "1.0.0-alpha.3",
+  "version": "1.0.0-alpha.7",
   "description": "Twitter for your NativeScript applications",
   "main": "index",
   "typings": "index.d.ts",
diff --git a/packages/twitter/platforms/ios/Podfile b/packages/twitter/platforms/ios/Podfile
index 9d5fc5c9..bafb039d 100644
--- a/packages/twitter/platforms/ios/Podfile
+++ b/packages/twitter/platforms/ios/Podfile
@@ -1,2 +1,3 @@
-pod 'TwitterKit5'
+platform :ios, '10.0'
+pod 'Swifter', :git => 'https://github.com/mattdonnelly/Swifter.git', :tag => "2.5.0"
 pod 'GoogleUtilities', '~> 7.5'
\ No newline at end of file
diff --git a/packages/twitter/platforms/ios/src/TNSTwitter.swift b/packages/twitter/platforms/ios/src/TNSTwitter.swift
new file mode 100644
index 00000000..65a73209
--- /dev/null
+++ b/packages/twitter/platforms/ios/src/TNSTwitter.swift
@@ -0,0 +1,106 @@
+import Foundation
+import Swifter
+import SafariServices
+import AuthenticationServices
+
+
+
+struct TNSSession: Codable {
+    var authToken: String?
+    var authTokenSecret: String?
+    var userName: String?
+    var userId: String?
+    
+    init(token: Credential.OAuthAccessToken){
+        authToken = token.key
+        authTokenSecret = token.secret
+        userName = token.screenName
+        userId = token.userID
+    }
+}
+
+
+
+@objcMembers
+@objc(TNSTwitter)
+public class TNSTwitter: NSObject {
+    private var swifter: Swifter
+    private var controller: UIViewController?
+    private let encoder = JSONEncoder()
+    
+    public static func handleOpenURL(_ url: String,_ callbackURL: String,_ isSSO: Bool) -> Bool {
+        return Swifter.handleOpenURL(URL(string: url)!, callbackURL: URL(string: callbackURL)!, isSSO: isSSO)
+    }
+    
+    public init?(_ consumerKey: String, _ consumerSecret: String) {
+        guard !consumerKey.isEmpty || !consumerSecret.isEmpty else {return nil}
+        swifter = Swifter(consumerKey: consumerKey, consumerSecret: consumerSecret)
+    }
+    
+    
+    private func handleSession(_ token: Credential.OAuthAccessToken, _ callback: @escaping ((String?, NSError?) -> Void)){
+        let session = TNSSession(token: token)
+        do {
+            callback(String(data: try self.encoder.encode(session), encoding: .utf8) ?? "", nil)
+        }catch {
+            callback(nil, error as NSError)
+        }
+    }
+    
+    public func verifyUser(
+        _ includeEntities: Bool,
+        _ skipStatus: Bool,
+        _ includeEmail: Bool,_ callback: @escaping ((String?, NSError?) -> Void)) {
+            swifter.verifyAccountCredentials(includeEntities: includeEntities, skipStatus: skipStatus, includeEmail: includeEmail) { user in
+                callback(String(describing: user), nil)
+            } failure: { error in
+                callback(nil, error as NSError)
+            }
+            
+        }
+    
+    public func authorizeWithSSO(_ callback: @escaping ((String?, NSError?) -> Void)){
+        swifter.authorizeSSO { token in
+            self.handleSession(token, callback)
+        } failure: { error in
+            callback(nil, error as NSError)
+        }
+    }
+    
+    public func authorizeWithBrowser(_ controller: UIViewController,_ callbackURL: String, _ callback: @escaping ((String?, NSError?) -> Void)){
+        self.controller = controller
+        if #available(iOS 13.0, *) {
+            swifter.authorize(withProvider: self, callbackURL: URL(string: callbackURL)!) { token, response in
+                self.controller = nil
+                self.handleSession(token!, callback)
+            } failure: {error in
+                self.controller = nil
+                callback(nil, error as NSError)
+            }
+        }else {
+            swifter.authorize(withCallback: URL(string: callbackURL)!, presentingFrom: controller) { token, response in
+                self.controller = nil
+                self.handleSession(token!, callback)
+            } failure: {error in
+                self.controller = nil
+                callback(nil, error as NSError)
+            }
+        }
+    }
+    
+}
+
+
+extension TNSTwitter: SFSafariViewControllerDelegate {
+    @nonobjc func safariViewControllerDidFinish(_ controller: SFSafariViewController) {
+        controller.dismiss(animated: true, completion: nil)
+    }
+}
+
+
+@available(iOS 13.0, *)
+extension TNSTwitter: ASWebAuthenticationPresentationContextProviding {
+    public func presentationAnchor(for session: ASWebAuthenticationSession) -> ASPresentationAnchor {
+        return controller!.view.window!
+    }
+}
diff --git a/packages/twitter/src-native/TwitterDemo/.idea/compiler.xml b/packages/twitter/src-native/TwitterDemo/.idea/compiler.xml
index 61a9130c..fb7f4a8a 100644
--- a/packages/twitter/src-native/TwitterDemo/.idea/compiler.xml
+++ b/packages/twitter/src-native/TwitterDemo/.idea/compiler.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="1.8" />
+    <bytecodeTargetLevel target="11" />
   </component>
 </project>
\ No newline at end of file
diff --git a/packages/twitter/src-native/TwitterDemo/.idea/gradle.xml b/packages/twitter/src-native/TwitterDemo/.idea/gradle.xml
index 85b7f0a0..0c43e68a 100644
--- a/packages/twitter/src-native/TwitterDemo/.idea/gradle.xml
+++ b/packages/twitter/src-native/TwitterDemo/.idea/gradle.xml
@@ -7,6 +7,7 @@
         <option name="testRunner" value="GRADLE" />
         <option name="distributionType" value="DEFAULT_WRAPPED" />
         <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleJvm" value="Android Studio default JDK" />
         <option name="modules">
           <set>
             <option value="$PROJECT_DIR$" />
diff --git a/packages/twitter/src-native/TwitterDemo/.idea/misc.xml b/packages/twitter/src-native/TwitterDemo/.idea/misc.xml
index fc42dde8..1b6dac90 100644
--- a/packages/twitter/src-native/TwitterDemo/.idea/misc.xml
+++ b/packages/twitter/src-native/TwitterDemo/.idea/misc.xml
@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_1_8" default="true" project-jdk-name="1.8 (2)" project-jdk-type="JavaSDK">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="11" project-jdk-type="JavaSDK">
     <output url="file://$PROJECT_DIR$/build/classes" />
   </component>
   <component name="ProjectType">
diff --git a/packages/twitter/typings/objc!nsswiftsupport.d.ts b/packages/twitter/typings/objc!nsswiftsupport.d.ts
new file mode 100644
index 00000000..dc3bf4d9
--- /dev/null
+++ b/packages/twitter/typings/objc!nsswiftsupport.d.ts
@@ -0,0 +1,228 @@
+
+declare class TNSTwitter extends NSObject implements ASWebAuthenticationPresentationContextProviding, SFSafariViewControllerDelegate {
+
+	static alloc(): TNSTwitter; // inherited from NSObject
+
+	static handleOpenURL(url: string, callbackURL: string, isSSO: boolean): boolean;
+
+	static new(): TNSTwitter; // inherited from NSObject
+
+	readonly debugDescription: string; // inherited from NSObjectProtocol
+
+	readonly description: string; // inherited from NSObjectProtocol
+
+	readonly hash: number; // inherited from NSObjectProtocol
+
+	readonly isProxy: boolean; // inherited from NSObjectProtocol
+
+	readonly superclass: typeof NSObject; // inherited from NSObjectProtocol
+
+	readonly  // inherited from NSObjectProtocol
+
+	constructor();
+
+	authorizeWithBrowser(controller: UIViewController, callbackURL: string, callback: (p1: string, p2: NSError) => void): void;
+
+	authorizeWithSSO(callback: (p1: string, p2: NSError) => void): void;
+
+	class(): typeof NSObject;
+
+	conformsToProtocol(aProtocol: any /* Protocol */): boolean;
+
+	init(consumerKey: string, consumerSecret: string): this;
+
+	isEqual(object: any): boolean;
+
+	isKindOfClass(aClass: typeof NSObject): boolean;
+
+	isMemberOfClass(aClass: typeof NSObject): boolean;
+
+	performSelector(aSelector: string): any;
+
+	performSelectorWithObject(aSelector: string, object: any): any;
+
+	performSelectorWithObjectWithObject(aSelector: string, object1: any, object2: any): any;
+
+	presentationAnchorForWebAuthenticationSession(session: ASWebAuthenticationSession): UIWindow;
+
+	respondsToSelector(aSelector: string): boolean;
+
+	retainCount(): number;
+
+	safariViewControllerActivityItemsForURLTitle(controller: SFSafariViewController, URL: NSURL, title: string): NSArray<UIActivity>;
+
+	safariViewControllerDidCompleteInitialLoad(controller: SFSafariViewController, didLoadSuccessfully: boolean): void;
+
+	safariViewControllerDidFinish(controller: SFSafariViewController): void;
+
+	safariViewControllerExcludedActivityTypesForURLTitle(controller: SFSafariViewController, URL: NSURL, title: string): NSArray<string>;
+
+	safariViewControllerInitialLoadDidRedirectToURL(controller: SFSafariViewController, URL: NSURL): void;
+
+	safariViewControllerWillOpenInBrowser(controller: SFSafariViewController): void;
+
+	self(): this;
+
+	verifyUser(includeEntities: boolean, skipStatus: boolean, includeEmail: boolean, callback: (p1: string, p2: NSError) => void): void;
+}
+
+declare class TNSTwitterAppDelegate extends UIResponder implements UIApplicationDelegate {
+
+	static alloc(): TNSTwitterAppDelegate; // inherited from NSObject
+
+	static new(): TNSTwitterAppDelegate; // inherited from NSObject
+
+	callback: string;
+
+	ssoCallback: string;
+
+	useSSO: boolean;
+
+	static readonly sharedInstance: TNSTwitterAppDelegate;
+
+	readonly debugDescription: string; // inherited from NSObjectProtocol
+
+	readonly description: string; // inherited from NSObjectProtocol
+
+	readonly hash: number; // inherited from NSObjectProtocol
+
+	readonly isProxy: boolean; // inherited from NSObjectProtocol
+
+	readonly superclass: typeof NSObject; // inherited from NSObjectProtocol
+
+	window: UIWindow; // inherited from UIApplicationDelegate
+
+	readonly  // inherited from NSObjectProtocol
+
+	applicationConfigurationForConnectingOptions(application: UIApplication, connectingSceneSession: UISceneSession, options: UISceneConnectionOptions): UISceneConfiguration;
+
+	applicationConfigurationForConnectingSceneSessionOptions(application: UIApplication, connectingSceneSession: UISceneSession, options: UISceneConnectionOptions): UISceneConfiguration;
+
+	applicationContinueUserActivityRestorationHandler(application: UIApplication, userActivity: NSUserActivity, restorationHandler: (p1: NSArray<UIUserActivityRestoring>) => void): boolean;
+
+	applicationDidBecomeActive(application: UIApplication): void;
+
+	applicationDidChangeStatusBarFrame(application: UIApplication, oldStatusBarFrame: CGRect): void;
+
+	applicationDidChangeStatusBarOrientation(application: UIApplication, oldStatusBarOrientation: UIInterfaceOrientation): void;
+
+	applicationDidDecodeRestorableStateWithCoder(application: UIApplication, coder: NSCoder): void;
+
+	applicationDidDiscardSceneSessions(application: UIApplication, sceneSessions: NSSet<UISceneSession>): void;
+
+	applicationDidEnterBackground(application: UIApplication): void;
+
+	applicationDidFailToContinueUserActivityWithTypeError(application: UIApplication, userActivityType: string, error: NSError): void;
+
+	applicationDidFailToRegisterForRemoteNotificationsWithError(application: UIApplication, error: NSError): void;
+
+	applicationDidFinishLaunching(application: UIApplication): void;
+
+	applicationDidFinishLaunchingWithOptions(application: UIApplication, launchOptions: NSDictionary<string, any>): boolean;
+
+	applicationDidReceiveLocalNotification(application: UIApplication, notification: UILocalNotification): void;
+
+	applicationDidReceiveMemoryWarning(application: UIApplication): void;
+
+	applicationDidReceiveRemoteNotification(application: UIApplication, userInfo: NSDictionary<any, any>): void;
+
+	applicationDidReceiveRemoteNotificationFetchCompletionHandler(application: UIApplication, userInfo: NSDictionary<any, any>, completionHandler: (p1: UIBackgroundFetchResult) => void): void;
+
+	applicationDidRegisterForRemoteNotificationsWithDeviceToken(application: UIApplication, deviceToken: NSData): void;
+
+	applicationDidRegisterUserNotificationSettings(application: UIApplication, notificationSettings: UIUserNotificationSettings): void;
+
+	applicationDidUpdateUserActivity(application: UIApplication, userActivity: NSUserActivity): void;
+
+	applicationHandleActionWithIdentifierForLocalNotificationCompletionHandler(application: UIApplication, identifier: string, notification: UILocalNotification, completionHandler: () => void): void;
+
+	applicationHandleActionWithIdentifierForLocalNotificationWithResponseInfoCompletionHandler(application: UIApplication, identifier: string, notification: UILocalNotification, responseInfo: NSDictionary<any, any>, completionHandler: () => void): void;
+
+	applicationHandleActionWithIdentifierForRemoteNotificationCompletionHandler(application: UIApplication, identifier: string, userInfo: NSDictionary<any, any>, completionHandler: () => void): void;
+
+	applicationHandleActionWithIdentifierForRemoteNotificationWithResponseInfoCompletionHandler(application: UIApplication, identifier: string, userInfo: NSDictionary<any, any>, responseInfo: NSDictionary<any, any>, completionHandler: () => void): void;
+
+	applicationHandleEventsForBackgroundURLSessionCompletionHandler(application: UIApplication, identifier: string, completionHandler: () => void): void;
+
+	applicationHandleIntentCompletionHandler(application: UIApplication, intent: INIntent, completionHandler: (p1: INIntentResponse) => void): void;
+
+	applicationHandleOpenURL(application: UIApplication, url: NSURL): boolean;
+
+	applicationHandleWatchKitExtensionRequestReply(application: UIApplication, userInfo: NSDictionary<any, any>, reply: (p1: NSDictionary<any, any>) => void): void;
+
+	applicationHandlerForIntent(application: UIApplication, intent: INIntent): any;
+
+	applicationOpenOptions(application: UIApplication, url: NSURL, options: NSDictionary<string, any>): boolean;
+
+	applicationOpenURLOptions(app: UIApplication, url: NSURL, options: NSDictionary<string, any>): boolean;
+
+	applicationOpenURLSourceApplicationAnnotation(application: UIApplication, url: NSURL, sourceApplication: string, annotation: any): boolean;
+
+	applicationPerformActionForShortcutItemCompletionHandler(application: UIApplication, shortcutItem: UIApplicationShortcutItem, completionHandler: (p1: boolean) => void): void;
+
+	applicationPerformFetchWithCompletionHandler(application: UIApplication, completionHandler: (p1: UIBackgroundFetchResult) => void): void;
+
+	applicationProtectedDataDidBecomeAvailable(application: UIApplication): void;
+
+	applicationProtectedDataWillBecomeUnavailable(application: UIApplication): void;
+
+	applicationShouldAllowExtensionPointIdentifier(application: UIApplication, extensionPointIdentifier: string): boolean;
+
+	applicationShouldAutomaticallyLocalizeKeyCommands(application: UIApplication): boolean;
+
+	applicationShouldRequestHealthAuthorization(application: UIApplication): void;
+
+	applicationShouldRestoreApplicationState(application: UIApplication, coder: NSCoder): boolean;
+
+	applicationShouldRestoreSecureApplicationState(application: UIApplication, coder: NSCoder): boolean;
+
+	applicationShouldSaveApplicationState(application: UIApplication, coder: NSCoder): boolean;
+
+	applicationShouldSaveSecureApplicationState(application: UIApplication, coder: NSCoder): boolean;
+
+	applicationSignificantTimeChange(application: UIApplication): void;
+
+	applicationSupportedInterfaceOrientationsForWindow(application: UIApplication, window: UIWindow): UIInterfaceOrientationMask;
+
+	applicationUserDidAcceptCloudKitShareWithMetadata(application: UIApplication, cloudKitShareMetadata: CKShareMetadata): void;
+
+	applicationViewControllerWithRestorationIdentifierPathCoder(application: UIApplication, identifierComponents: NSArray<string> | string[], coder: NSCoder): UIViewController;
+
+	applicationWillChangeStatusBarFrame(application: UIApplication, newStatusBarFrame: CGRect): void;
+
+	applicationWillChangeStatusBarOrientationDuration(application: UIApplication, newStatusBarOrientation: UIInterfaceOrientation, duration: number): void;
+
+	applicationWillContinueUserActivityWithType(application: UIApplication, userActivityType: string): boolean;
+
+	applicationWillEncodeRestorableStateWithCoder(application: UIApplication, coder: NSCoder): void;
+
+	applicationWillEnterForeground(application: UIApplication): void;
+
+	applicationWillFinishLaunchingWithOptions(application: UIApplication, launchOptions: NSDictionary<string, any>): boolean;
+
+	applicationWillResignActive(application: UIApplication): void;
+
+	applicationWillTerminate(application: UIApplication): void;
+
+	class(): typeof NSObject;
+
+	conformsToProtocol(aProtocol: any /* Protocol */): boolean;
+
+	isEqual(object: any): boolean;
+
+	isKindOfClass(aClass: typeof NSObject): boolean;
+
+	isMemberOfClass(aClass: typeof NSObject): boolean;
+
+	performSelector(aSelector: string): any;
+
+	performSelectorWithObject(aSelector: string, object: any): any;
+
+	performSelectorWithObjectWithObject(aSelector: string, object1: any, object2: any): any;
+
+	respondsToSelector(aSelector: string): boolean;
+
+	retainCount(): number;
+
+	self(): this;
+}