diff --git a/.github/workflows/native_auth_flutter.yaml b/.github/workflows/native_auth_flutter.yaml new file mode 100644 index 0000000..c7b6464 --- /dev/null +++ b/.github/workflows/native_auth_flutter.yaml @@ -0,0 +1,45 @@ +name: native_auth_flutter +on: + pull_request: + paths: + - ".github/workflows/native_auth_flutter.yaml" + - "packages/native/auth/native_auth_flutter/**" + +# Prevent duplicate runs due to Graphite +# https://graphite.dev/docs/troubleshooting#why-are-my-actions-running-twice +concurrency: + group: ${{ github.repository }}-${{ github.workflow }}-${{ github.ref }}-${{ github.ref == 'refs/heads/main' && github.sha || ''}} + cancel-in-progress: true + +defaults: + run: + working-directory: packages/native/auth/native_auth_flutter + +jobs: + build: + runs-on: macos-latest-xlarge + timeout-minutes: 25 + steps: + - name: Git Checkout + uses: actions/checkout@a5ac7e51b41094c92402da3b24376905380afc29 # 4.1.6 + - name: Setup Flutter + uses: subosito/flutter-action@44ac965b96f18d999802d4b807e3256d5a3f9fa1 # 2.16.0 + with: + channel: stable + cache: true + - name: Get Packages + run: flutter pub get + - name: Analyze + run: dart analyze --fatal-infos --fatal-warnings + - name: Format + run: dart format --set-exit-if-changed . + # - name: Test + # run: dart test + # - name: Test (Example) + # run: dart test + - name: Build Example (iOS) + run: flutter build ios --no-codesign + working-directory: packages/native/auth/native_auth_flutter/example + - name: Build Example (Web) + run: flutter build web + working-directory: packages/native/auth/native_auth_flutter/example diff --git a/packages/native/auth/native_auth_flutter/.gitignore b/packages/native/auth/native_auth_flutter/.gitignore new file mode 100644 index 0000000..ac5aa98 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/.gitignore @@ -0,0 +1,29 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.buildlog/ +.history +.svn/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# The .vscode folder contains launch configuration and tasks you configure in +# VS Code which you may wish to be included in version control, so this line +# is commented out by default. +#.vscode/ + +# Flutter/Dart/Pub related +# Libraries should not include pubspec.lock, per https://dart.dev/guides/libraries/private-files#pubspeclock. +/pubspec.lock +**/doc/api/ +.dart_tool/ +build/ diff --git a/packages/native/auth/native_auth_flutter/.metadata b/packages/native/auth/native_auth_flutter/.metadata new file mode 100644 index 0000000..d832fc3 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/.metadata @@ -0,0 +1,36 @@ +# This file tracks properties of this Flutter project. +# Used by Flutter tool to assess capabilities and perform upgrades etc. +# +# This file should be version controlled and should not be manually edited. + +version: + revision: "80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819" + channel: "stable" + +project_type: plugin_ffi + +# Tracks metadata for the flutter migrate command +migration: + platforms: + - platform: root + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + - platform: android + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + - platform: ios + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + - platform: macos + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + + # User provided section + + # List of Local paths (relative to this file) that should be + # ignored by the migrate tool. + # + # Files that are not part of the templates will be ignored by default. + unmanaged_files: + - 'lib/main.dart' + - 'ios/Runner.xcodeproj/project.pbxproj' diff --git a/packages/native/auth/native_auth_flutter/CHANGELOG.md b/packages/native/auth/native_auth_flutter/CHANGELOG.md new file mode 100644 index 0000000..090fc36 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/CHANGELOG.md @@ -0,0 +1,3 @@ +## 0.1.0 + +- Initial release diff --git a/packages/native/auth/native_auth_flutter/LICENSE b/packages/native/auth/native_auth_flutter/LICENSE new file mode 100644 index 0000000..ba75c69 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/LICENSE @@ -0,0 +1 @@ +TODO: Add your license here. diff --git a/packages/native/auth/native_auth_flutter/README.md b/packages/native/auth/native_auth_flutter/README.md new file mode 100644 index 0000000..6a98891 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/README.md @@ -0,0 +1,92 @@ +# native_auth_flutter + +A new Flutter FFI plugin project. + +## Getting Started + +This project is a starting point for a Flutter +[FFI plugin](https://flutter.dev/to/ffi-package), +a specialized package that includes native code directly invoked with Dart FFI. + +## Project structure + +This template uses the following structure: + +* `src`: Contains the native source code, and a CmakeFile.txt file for building + that source code into a dynamic library. + +* `lib`: Contains the Dart code that defines the API of the plugin, and which + calls into the native code using `dart:ffi`. + +* platform folders (`android`, `ios`, `windows`, etc.): Contains the build files + for building and bundling the native code library with the platform application. + +## Building and bundling native code + +The `pubspec.yaml` specifies FFI plugins as follows: + +```yaml + plugin: + platforms: + some_platform: + ffiPlugin: true +``` + +This configuration invokes the native build for the various target platforms +and bundles the binaries in Flutter applications using these FFI plugins. + +This can be combined with dartPluginClass, such as when FFI is used for the +implementation of one platform in a federated plugin: + +```yaml + plugin: + implements: some_other_plugin + platforms: + some_platform: + dartPluginClass: SomeClass + ffiPlugin: true +``` + +A plugin can have both FFI and method channels: + +```yaml + plugin: + platforms: + some_platform: + pluginClass: SomeName + ffiPlugin: true +``` + +The native build systems that are invoked by FFI (and method channel) plugins are: + +* For Android: Gradle, which invokes the Android NDK for native builds. + * See the documentation in android/build.gradle. +* For iOS and MacOS: Xcode, via CocoaPods. + * See the documentation in ios/native_auth_flutter.podspec. + * See the documentation in macos/native_auth_flutter.podspec. +* For Linux and Windows: CMake. + * See the documentation in linux/CMakeLists.txt. + * See the documentation in windows/CMakeLists.txt. + +## Binding to native code + +To use the native code, bindings in Dart are needed. +To avoid writing these by hand, they are generated from the header file +(`src/native_auth_flutter.h`) by `package:ffigen`. +Regenerate the bindings by running `dart run ffigen --config ffigen.yaml`. + +## Invoking native code + +Very short-running native functions can be directly invoked from any isolate. +For example, see `sum` in `lib/native_auth_flutter.dart`. + +Longer-running functions should be invoked on a helper isolate to avoid +dropping frames in Flutter applications. +For example, see `sumAsync` in `lib/native_auth_flutter.dart`. + +## Flutter help + +For help getting started with Flutter, view our +[online documentation](https://docs.flutter.dev), which offers tutorials, +samples, guidance on mobile development, and a full API reference. + diff --git a/packages/native/auth/native_auth_flutter/analysis_options.yaml b/packages/native/auth/native_auth_flutter/analysis_options.yaml new file mode 100644 index 0000000..17d3b91 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/analysis_options.yaml @@ -0,0 +1,5 @@ +include: package:flutter_lints/flutter.yaml + +analyzer: + exclude: + - '**/*.ffi.dart' diff --git a/packages/native/auth/native_auth_flutter/android/.gitignore b/packages/native/auth/native_auth_flutter/android/.gitignore new file mode 100644 index 0000000..161bdcd --- /dev/null +++ b/packages/native/auth/native_auth_flutter/android/.gitignore @@ -0,0 +1,9 @@ +*.iml +.gradle +/local.properties +/.idea/workspace.xml +/.idea/libraries +.DS_Store +/build +/captures +.cxx diff --git a/packages/native/auth/native_auth_flutter/android/build.gradle b/packages/native/auth/native_auth_flutter/android/build.gradle new file mode 100644 index 0000000..53f4ff6 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/android/build.gradle @@ -0,0 +1,69 @@ +group = "dev.celest.native_auth" +version = "1.0" + +buildscript { + // Matches package:jni + // https://github.com/dart-lang/native/blob/main/pkgs/jni/android/build.gradle#L7 + ext.kotlin_version = '1.6.10' + repositories { + google() + mavenCentral() + } + + dependencies { + classpath "com.android.tools.build:gradle:7.4.2" + classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version" + } +} + +rootProject.allprojects { + repositories { + google() + mavenCentral() + } +} + +apply plugin: "com.android.library" +apply plugin: 'kotlin-android' + +android { + if (project.android.hasProperty("namespace")) { + namespace = "dev.celest.native_auth" + } + + compileSdk 34 + + compileOptions { + sourceCompatibility JavaVersion.VERSION_1_8 + targetCompatibility JavaVersion.VERSION_1_8 + } + + kotlinOptions { + jvmTarget = '1.8' + } + + sourceSets { + main.java.srcDirs += 'src/main/kotlin' + } + + defaultConfig { + minSdkVersion 21 + consumerProguardFiles 'consumer-rules.pro' + } + + buildTypes { + release { + minifyEnabled false + } + } + + testOptions { + unitTests { + includeAndroidResources = true + } + } +} + +dependencies { + implementation "androidx.browser:browser:1.8.0" +} diff --git a/packages/native/auth/native_auth_flutter/android/consumer-rules.pro b/packages/native/auth/native_auth_flutter/android/consumer-rules.pro new file mode 100644 index 0000000..4fd9b88 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/android/consumer-rules.pro @@ -0,0 +1,5 @@ +-keep class dev.celest.native_auth.** { *; } +-if class androidx.credentials.CredentialManager +-keep class androidx.credentials.playservices.** { + *; +} \ No newline at end of file diff --git a/packages/native/auth/native_auth_flutter/android/settings.gradle b/packages/native/auth/native_auth_flutter/android/settings.gradle new file mode 100644 index 0000000..71782d6 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/android/settings.gradle @@ -0,0 +1 @@ +rootProject.name = 'native_auth_flutter' diff --git a/packages/native/auth/native_auth_flutter/android/src/main/AndroidManifest.xml b/packages/native/auth/native_auth_flutter/android/src/main/AndroidManifest.xml new file mode 100644 index 0000000..2e8b294 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/android/src/main/AndroidManifest.xml @@ -0,0 +1,30 @@ + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/packages/native/auth/native_auth_flutter/android/src/main/kotlin/dev/celest/native_auth/NativeAuth.kt b/packages/native/auth/native_auth_flutter/android/src/main/kotlin/dev/celest/native_auth/NativeAuth.kt new file mode 100644 index 0000000..6c5220e --- /dev/null +++ b/packages/native/auth/native_auth_flutter/android/src/main/kotlin/dev/celest/native_auth/NativeAuth.kt @@ -0,0 +1,214 @@ +package dev.celest.native_auth + +import android.content.ComponentName +import android.content.Intent +import android.net.Uri +import android.os.Build +import android.os.Bundle +import android.os.CancellationSignal +import androidx.annotation.UiThread +import androidx.browser.customtabs.CustomTabsCallback +import androidx.browser.customtabs.CustomTabsClient +import androidx.browser.customtabs.CustomTabsServiceConnection +import androidx.browser.customtabs.CustomTabsSession +import androidx.browser.trusted.TrustedWebActivityDisplayMode +import androidx.browser.trusted.TrustedWebActivityIntentBuilder +import androidx.lifecycle.MutableLiveData +import io.flutter.Log +import io.flutter.embedding.android.FlutterActivity + +/** + * A callback to an asynchronous auth flow. + */ +interface NativeAuthCallback { + fun onMessage(message: T) +} + +/** + * Platform authorization methods. + */ +class NativeAuth( + private val mainActivity: FlutterActivity, + private val redirectCallback: NativeAuthCallback +) { + + companion object { + private const val TAG = "NativeAuth" + + /** + * The current redirect flow state, shared between the activities which handle redirects. + */ + internal val currentState = MutableLiveData() + + /** + * Keys used to communicate data between the different redirect activities via Intents. + */ + internal const val KEY_AUTH_INTENT = "NativeAuth.AUTHORIZATION_INTENT" + internal const val KEY_AUTHORIZATION_STARTED = "NativeAuth.AUTHORIZATION_STARTED" + internal const val KEY_AUTH_REQUEST_ID = "NativeAuth.AUTH_REQUEST_ID" + internal const val KEY_AUTH_REQUEST_URI = "NativeAuth.AUTH_REQUEST_URI" + + /** + * Possible result values of a redirect. + */ + const val RESULT_OK = 0 + const val RESULT_FAILURE = 1 + const val RESULT_CANCELED = 2 + } + + init { + mainActivity.runOnUiThread { + listenForRedirects() + bindCustomTabsService() + } + } + + @UiThread + private fun listenForRedirects() { + currentState.observe(mainActivity) { + Log.d(TAG, "Redirect state change: $it") + val result = when (it) { + is NativeAuthRedirectState.Success -> NativeAuthRedirectResult( + it.id, + RESULT_OK, + uri = it.redirectUri + ) + + is NativeAuthRedirectState.Canceled -> NativeAuthRedirectResult( + it.id, + RESULT_CANCELED + ) + + is NativeAuthRedirectState.Failure -> NativeAuthRedirectResult( + it.id, + RESULT_FAILURE, + error = it.error + ) + + else -> null + } + result?.let { res -> redirectCallback.onMessage(res) } + } + } + + /** + * Configure the Custom Tabs service on initialization to prevent delays when launching + * redirects via the browser. + */ + + private var customTabsClient: CustomTabsClient? = null + private var customTabsSession: CustomTabsSession? = null + private val customTabsConnection = object : CustomTabsServiceConnection() { + override fun onServiceDisconnected(name: ComponentName?) { + Log.d(TAG, "onServiceDisconnected") + customTabsClient = null + customTabsSession = null + } + + override fun onCustomTabsServiceConnected(name: ComponentName, client: CustomTabsClient) { + Log.d(TAG, "onCustomTabsServiceConnected") + customTabsClient = client + client.warmup(0) + customTabsSession = client.newSession(CustomTabsCallback()) + } + } + + private fun bindCustomTabsService(): Boolean { + if (customTabsClient != null) { + return true + } + val packageName = CustomTabsClient.getPackageName(mainActivity, null) + if (packageName == null) { + Log.w(TAG, "Custom tabs service is unavailable") + return false + } + return CustomTabsClient.bindCustomTabsService( + mainActivity, packageName, + customTabsConnection + ) + } + + private fun unbindCustomTabsService() { + if (customTabsClient == null) { + return + } + mainActivity.unbindService(customTabsConnection) + } + + /** + * Starts a redirect session for the given URI. + * + * This function returns immediately with a unique session token. The result of the flow is + * communicated via the callbacks passed to the constructor. + * + * Every session is guaranteed to receive exactly one callback. + */ + fun startRedirect(sessionId: Int, uri: Uri): CancellationSignal { + val cancellationSignal = CancellationSignal() + val sessionData = NativeAuthRedirectSession(sessionId, uri, cancellationSignal) + + val authIntent = createAuthIntent(sessionData) + val startIntent = createStartIntent(sessionData, authIntent) + mainActivity.startActivity(startIntent) + mainActivity.runOnUiThread { + currentState.value = + NativeAuthRedirectState.Pending(sessionData.id, sessionData.startUri) + } + + return cancellationSignal + } + + /** + * Create the Custom Tabs intent which will be launched from a separate task. + */ + private fun createAuthIntent(session: NativeAuthRedirectSession): Intent { + val trustedWebIntent = TrustedWebActivityIntentBuilder(session.startUri) + .setDisplayMode(TrustedWebActivityDisplayMode.DefaultMode()) // ImmersiveMode? + .setAdditionalTrustedOrigins(mutableListOf()) // TODO + val intent = if (customTabsSession != null) { + Log.d(TAG, "Launching Trusted Web activity") + val launcher = trustedWebIntent.build(customTabsSession!!) + launcher.intent + } else { + Log.d(TAG, "Trusted Web provider unavailable. Launching Custom Tabs.") + val launcher = trustedWebIntent.buildCustomTabsIntent() + launcher.intent + } + + // Fixes an issue for older Android versions where the custom tab will background the app on + // redirect. Setting `FLAG_ACTIVITY_NEW_TASK` is the only fix since Flutter specifies + // `android:launchMode="singleInstance"` in the manifest. + // + // See: https://stackoverflow.com/questions/36084681/chrome-custom-tabs-redirect-to-android-app-will-close-the-app + if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) { + intent.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY) + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) + } + intent.putExtra( + Intent.EXTRA_REFERRER, + Uri.parse("android-app://${mainActivity.packageName}") + ) + intent.data = session.startUri + return intent + } + + /** + * Create the intent to start the redirect task. + * + * The redirect task is managed independently from the main activity so that its lifecycle + * can be deterministically handled. + */ + private fun createStartIntent( + session: NativeAuthRedirectSession, + authIntent: Intent, + ): Intent { + return Intent(mainActivity, NativeAuthRedirectManagerActivity::class.java).apply { + putExtra(KEY_AUTH_INTENT, authIntent) + putExtra(KEY_AUTH_REQUEST_URI, session.startUri) + putExtra(KEY_AUTH_REQUEST_ID, session.id) + } + } +} + +@Suppress("DEPRECATION") // Only used for debugging +internal fun Bundle.toMap() = keySet().associateWith { get(it).toString() } diff --git a/packages/native/auth/native_auth_flutter/android/src/main/kotlin/dev/celest/native_auth/NativeAuthRedirect.kt b/packages/native/auth/native_auth_flutter/android/src/main/kotlin/dev/celest/native_auth/NativeAuthRedirect.kt new file mode 100644 index 0000000..d615cfe --- /dev/null +++ b/packages/native/auth/native_auth_flutter/android/src/main/kotlin/dev/celest/native_auth/NativeAuthRedirect.kt @@ -0,0 +1,347 @@ +package dev.celest.native_auth + +import android.app.Activity +import android.content.ActivityNotFoundException +import android.content.Intent +import android.net.Uri +import android.os.Bundle +import android.os.CancellationSignal +import android.os.PersistableBundle +import androidx.annotation.UiThread +import io.flutter.Log + +/** + * An identifying token for an ongoing redirect. + */ +data class NativeAuthRedirectSession( + val id: Int, + val startUri: Uri, + val cancellationSignal: CancellationSignal, +) + +/** + * The result of a redirect session. + */ +data class NativeAuthRedirectResult( + val id: Int, + val resultCode: Int, + val uri: Uri? = null, + val error: Throwable? = null, +) + +/** + * The internal state of an ongoing redirect session. + */ +internal sealed class NativeAuthRedirectState { + abstract val id: Int + + data class Pending(override val id: Int, val startUri: Uri) : NativeAuthRedirectState() + data class Launched(override val id: Int) : NativeAuthRedirectState() + data class Success(override val id: Int, val redirectUri: Uri) : NativeAuthRedirectState() + data class Canceled(override val id: Int) : NativeAuthRedirectState() + data class Failure(override val id: Int, val error: Throwable) : NativeAuthRedirectState() +} + +// Classes below are modified from AppAuth's AuthorizationManagementActivity and +// RedirectUriReceiver activities. +// +// https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/AuthorizationManagementActivity.java +// https://github.com/openid/AppAuth-Android/blob/master/library/java/net/openid/appauth/RedirectUriReceiverActivity.java + +/** + * Stores state and handles events related to the authorization management flow. The activity is + * started by {@link AuthorizationService#performAuthorizationRequest} or + * {@link AuthorizationService#performEndSessionRequest}, and records all state pertinent to + * the authorization management request before invoking the authorization intent. It also functions + * to control the back stack, ensuring that the authorization activity will not be reachable + * via the back button after the flow completes. + * + * The following diagram illustrates the operation of the activity: + * + * ``` + * Back Stack Towards Top + * +------------------------------------------> + * + * +------------+ +---------------+ +----------------+ +--------------+ + * | | (1) | | (2) | | (S1) | | + * | Initiating +----------->| Authorization +----->| Authorization +----->| Redirect URI | + * | Activity | | Management | | Activity | | Receiver | + * | |<-----------+ Activity |<-----+ (e.g. browser) | | Activity | + * | | (C2b, S3b) | | (C1) | | | | + * +------------+ +-+---+---------+ +----------------+ +-------+------+ + * | | ^ | + * | | | | + * +-------+ | | (S2) | + * | | +----------------------------------------------+ + * | | + * | v (S3a) + * (C2a) | +------------+ + * | | | + * | | Completion | + * | | Activity | + * | | | + * | +------------+ + * | + * | +-------------+ + * | | | + * +----->| Cancelation | + * | Activity | + * | | + * +-------------+ + * ``` + * + * The process begins with an activity requesting that an authorization flow be started, + * using {@link AuthorizationService#performAuthorizationRequest} or + * {@link AuthorizationService#performEndSessionRequest}. + * + * - Step 1: Using an intent derived from {@link #createStartIntent}, this activity is + * started. The state delivered in this intent is recorded for future use. + * + * - Step 2: The authorization intent, typically a browser tab, is started. At this point, + * depending on user action, we will either end up in a "completion" flow (S) or + * "cancelation flow" (C). + * + * - Cancelation (C) flow: + * - Step C1: If the user presses the back button or otherwise causes the authorization + * activity to finish, the AuthorizationManagementActivity will be recreated or restarted. + * + * - Step C2a: If a cancellation PendingIntent was provided in the call to + * {@link AuthorizationService#performAuthorizationRequest} or + * {@link AuthorizationService#performEndSessionRequest}, then this is + * used to invoke a cancelation activity. + * + * - Step C2b: If no cancellation PendingIntent was provided (legacy behavior, or + * AuthorizationManagementActivity was started with an intent from + * {@link AuthorizationService#getAuthorizationRequestIntent} or + * @link AuthorizationService#performEndOfSessionRequest}), then the + * AuthorizationManagementActivity simply finishes after calling {@link Activity#setResult}, + * with {@link Activity#RESULT_CANCELED}, returning control to the activity above + * it in the back stack (typically, the initiating activity). + * + * - Completion (S) flow: + * - Step S1: The authorization activity completes with a success or failure, and sends this + * result to {@link RedirectUriReceiverActivity}. + * + * - Step S2: {@link RedirectUriReceiverActivity} extracts the forwarded data, and invokes + * AuthorizationManagementActivity using an intent derived from + * {@link #createResponseHandlingIntent}. This intent has flag CLEAR_TOP set, which will + * result in both the authorization activity and {@link RedirectUriReceiverActivity} being + * destroyed, if necessary, such that AuthorizationManagementActivity is once again at the + * top of the back stack. + * + * - Step S3a: If this activity was invoked via + * {@link AuthorizationService#performAuthorizationRequest} or + * {@link AuthorizationService#performEndSessionRequest}, then the pending intent provided + * for completion of the authorization flow is invoked, providing the decoded + * {@link AuthorizationManagementResponse} or {@link AuthorizationException} as appropriate. + * The AuthorizationManagementActivity finishes, removing itself from the back stack. + * + * - Step S3b: If this activity was invoked via an intent returned by + * {@link AuthorizationService#getAuthorizationRequestIntent}, then this activity + * calls {@link Activity#setResult(int, Intent)} with {@link Activity#RESULT_OK} + * and a data intent containing the {@link AuthorizationResponse} or + * {@link AuthorizationException} as appropriate. + * The AuthorizationManagementActivity finishes, removing itself from the back stack. + */ +class NativeAuthRedirectManagerActivity : Activity() { + companion object { + const val TAG = "NativeAuthRedirectManagerActivity" + } + + private var initialized = false + private var authorizationStarted = false + private lateinit var authIntent: Intent + private lateinit var startUri: Uri + private var sessionId: Int = -1 + + override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) { + super.onCreate(savedInstanceState, persistentState) + Log.d(TAG, "onCreate: intent=${intent}, intent.extras=${intent.extras?.toMap()}") + + if (savedInstanceState != null) { + extractState(savedInstanceState) + } else { + extractState(intent.extras) + } + } + + private fun extractState(state: Bundle?): Boolean { + if (initialized) { + return true + } + + fun fail(message: String): Boolean { + finishWithResult( + NativeAuthRedirectState.Failure( + -1, + Exception("Unable to handle response: $message") + ) + ) + return false + } + if (state == null) { + return fail("No stored state") + } + + @Suppress("DEPRECATION") // Replacement only available in API 33+ + run { + authIntent = state.getParcelable(NativeAuth.KEY_AUTH_INTENT) + ?: return fail("Missing auth intent") + authorizationStarted = state.getBoolean(NativeAuth.KEY_AUTHORIZATION_STARTED, false) + startUri = + state.getParcelable(NativeAuth.KEY_AUTH_REQUEST_URI) + ?: return fail("Missing start URI") + sessionId = state.getInt(NativeAuth.KEY_AUTH_REQUEST_ID) + } + + Log.d(TAG, "sessionState($sessionId): authorizationStarted=$authorizationStarted") + initialized = true + return true + } + + override fun onResume() { + super.onResume() + Log.d(TAG, "onResume: intent=${intent}, intent.extras=${intent.extras?.toMap()}") + + if (!extractState(intent.extras)) { + return + } + + /* + * If this is the first run of the activity, start the authorization intent. + * Note that we do not finish the activity at this point, in order to remain on the back + * stack underneath the authorization activity. + */ + if (!authorizationStarted) { + try { + startActivity(authIntent) + authorizationStarted = true + NativeAuth.currentState.postValue( + NativeAuthRedirectState.Launched(sessionId) + ) + } catch (e: ActivityNotFoundException) { + browserNotFound(e) + } + return + } + + /* + * On a subsequent run, it must be determined whether we have returned to this activity + * due to an OAuth2 redirect, or the user canceling the authorization flow. This can + * be done by checking whether a response URI is available, which would be provided by + * RedirectUriReceiverActivity. If it is not, we have returned here due to the user + * pressing the back button, or the authorization activity finishing without + * RedirectUriReceiverActivity having been invoked - this can occur when the user presses + * the back button, or closes the browser tab. + */ + if (intent.data != null) { + authorizationComplete() + } else { + authorizationCanceled() + } + } + + @UiThread + private fun finishWithResult(state: NativeAuthRedirectState) { + Log.d(TAG, "Completing with state=$state") + NativeAuth.currentState.postValue(state) + setResult( + when (state) { + is NativeAuthRedirectState.Success -> RESULT_OK + else -> RESULT_CANCELED + } + ) + finish() + } + + private fun browserNotFound(e: Throwable) { + Log.e(TAG, "Authorization flow canceled: missing browser") + finishWithResult( + NativeAuthRedirectState.Failure(sessionId, Exception("No browser found", e)), + ) + } + + private fun authorizationComplete() { + val redirectUri = intent.data + Log.d(TAG, "Authorization completed: data=$redirectUri") + finishWithResult( + if (redirectUri != null) + NativeAuthRedirectState.Success(sessionId, redirectUri) + else + NativeAuthRedirectState.Failure(sessionId, Exception("No data present in redirect")) + ) + } + + private fun authorizationCanceled() { + Log.d(TAG, "Authorization flow canceled by user") + finishWithResult( + NativeAuthRedirectState.Canceled(sessionId) + ) + } + + override fun onNewIntent(intent: Intent?) { + super.onNewIntent(intent) + Log.d(TAG, "onNewIntent: intent=${intent}, intent.extras=${intent?.extras?.toMap()}") + this.intent = intent + } + + override fun onSaveInstanceState(outState: Bundle) { + super.onSaveInstanceState(outState) + outState.putBoolean(NativeAuth.KEY_AUTHORIZATION_STARTED, authorizationStarted) + outState.putParcelable(NativeAuth.KEY_AUTH_INTENT, authIntent) + outState.putParcelable(NativeAuth.KEY_AUTH_REQUEST_URI, startUri) + outState.putInt(NativeAuth.KEY_AUTH_REQUEST_ID, sessionId) + } +} + +/** + * Activity that receives the redirect Uri sent by the OpenID endpoint. It forwards the data + * received as part of this redirect to {@link AuthorizationManagementActivity}, which + * destroys the browser tab before returning the result to the completion + * {@link android.app.PendingIntent} + * provided to {@link AuthorizationService#performAuthorizationRequest}. + * + * App developers using this library must override the `appAuthRedirectScheme` + * property in their `build.gradle` to specify the custom scheme that will be used for + * the OAuth2 redirect. If custom scheme redirect cannot be used with the identity provider + * you are integrating with, then a custom intent filter should be defined in your + * application manifest instead. For example, to handle + * `https://www.example.com/oauth2redirect`: + * + * ```xml + * + * + * + * + * + * + * ``` + */ +class NativeAuthRedirectReceiverActivity : Activity() { + companion object { + const val TAG = "NativeAuthRedirectReceiverActivity" + } + + override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) { + super.onCreate(savedInstanceState, persistentState) + Log.d(TAG, "onCreate") + } + + override fun onResume() { + super.onResume() + Log.d(TAG, "onResume: intent=$intent, intent.extras=${intent.extras?.toMap()}") + + // while this does not appear to be achieving much, handling the redirect in this way + // ensures that we can remove the browser tab from the back stack. See the documentation + // on AuthorizationManagementActivity for more details. + val intent = Intent(this, NativeAuthRedirectManagerActivity::class.java).apply { + data = intent.data + putExtra(NativeAuth.KEY_AUTH_REQUEST_URI, intent.data) + addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP) + } + startActivity(intent) + finish() + } +} diff --git a/packages/native/auth/native_auth_flutter/example/.gitignore b/packages/native/auth/native_auth_flutter/example/.gitignore new file mode 100644 index 0000000..29a3a50 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/.gitignore @@ -0,0 +1,43 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.buildlog/ +.history +.svn/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# The .vscode folder contains launch configuration and tasks you configure in +# VS Code which you may wish to be included in version control, so this line +# is commented out by default. +#.vscode/ + +# Flutter/Dart/Pub related +**/doc/api/ +**/ios/Flutter/.last_build_id +.dart_tool/ +.flutter-plugins +.flutter-plugins-dependencies +.pub-cache/ +.pub/ +/build/ + +# Symbolication related +app.*.symbols + +# Obfuscation related +app.*.map.json + +# Android Studio will place build artifacts here +/android/app/debug +/android/app/profile +/android/app/release diff --git a/packages/native/auth/native_auth_flutter/example/.metadata b/packages/native/auth/native_auth_flutter/example/.metadata new file mode 100644 index 0000000..90eabcf --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/.metadata @@ -0,0 +1,45 @@ +# This file tracks properties of this Flutter project. +# Used by Flutter tool to assess capabilities and perform upgrades etc. +# +# This file should be version controlled and should not be manually edited. + +version: + revision: "80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819" + channel: "stable" + +project_type: app + +# Tracks metadata for the flutter migrate command +migration: + platforms: + - platform: root + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + - platform: android + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + - platform: ios + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + - platform: linux + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + - platform: macos + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + - platform: web + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + - platform: windows + create_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + base_revision: 80c2e84975bbd28ecf5f8d4bd4ca5a2490bfc819 + + # User provided section + + # List of Local paths (relative to this file) that should be + # ignored by the migrate tool. + # + # Files that are not part of the templates will be ignored by default. + unmanaged_files: + - 'lib/main.dart' + - 'ios/Runner.xcodeproj/project.pbxproj' diff --git a/packages/native/auth/native_auth_flutter/example/README.md b/packages/native/auth/native_auth_flutter/example/README.md new file mode 100644 index 0000000..232ff29 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/README.md @@ -0,0 +1,16 @@ +# native_auth_flutter_example + +Demonstrates how to use the native_auth_flutter plugin. + +## Getting Started + +This project is a starting point for a Flutter application. + +A few resources to get you started if this is your first Flutter project: + +- [Lab: Write your first Flutter app](https://docs.flutter.dev/get-started/codelab) +- [Cookbook: Useful Flutter samples](https://docs.flutter.dev/cookbook) + +For help getting started with Flutter development, view the +[online documentation](https://docs.flutter.dev/), which offers tutorials, +samples, guidance on mobile development, and a full API reference. diff --git a/packages/native/auth/native_auth_flutter/example/analysis_options.yaml b/packages/native/auth/native_auth_flutter/example/analysis_options.yaml new file mode 100644 index 0000000..0d29021 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/analysis_options.yaml @@ -0,0 +1,28 @@ +# This file configures the analyzer, which statically analyzes Dart code to +# check for errors, warnings, and lints. +# +# The issues identified by the analyzer are surfaced in the UI of Dart-enabled +# IDEs (https://dart.dev/tools#ides-and-editors). The analyzer can also be +# invoked from the command line by running `flutter analyze`. + +# The following line activates a set of recommended lints for Flutter apps, +# packages, and plugins designed to encourage good coding practices. +include: package:flutter_lints/flutter.yaml + +linter: + # The lint rules applied to this project can be customized in the + # section below to disable rules from the `package:flutter_lints/flutter.yaml` + # included above or to enable additional rules. A list of all available lints + # and their documentation is published at https://dart.dev/lints. + # + # Instead of disabling a lint rule for the entire project in the + # section below, it can also be suppressed for a single line of code + # or a specific dart file by using the `// ignore: name_of_lint` and + # `// ignore_for_file: name_of_lint` syntax on the line or in the file + # producing the lint. + rules: + # avoid_print: false # Uncomment to disable the `avoid_print` rule + # prefer_single_quotes: true # Uncomment to enable the `prefer_single_quotes` rule + +# Additional information about this file can be found at +# https://dart.dev/guides/language/analysis-options diff --git a/packages/native/auth/native_auth_flutter/example/android/.gitignore b/packages/native/auth/native_auth_flutter/example/android/.gitignore new file mode 100644 index 0000000..55afd91 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/.gitignore @@ -0,0 +1,13 @@ +gradle-wrapper.jar +/.gradle +/captures/ +/gradlew +/gradlew.bat +/local.properties +GeneratedPluginRegistrant.java + +# Remember to never publicly share your keystore. +# See https://flutter.dev/to/reference-keystore +key.properties +**/*.keystore +**/*.jks diff --git a/packages/native/auth/native_auth_flutter/example/android/app/build.gradle b/packages/native/auth/native_auth_flutter/example/android/app/build.gradle new file mode 100644 index 0000000..bf6e356 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/app/build.gradle @@ -0,0 +1,50 @@ +plugins { + id "com.android.application" + id "kotlin-android" + // The Flutter Gradle Plugin must be applied after the Android and Kotlin Gradle plugins. + id "dev.flutter.flutter-gradle-plugin" +} + +android { + namespace = "dev.celest.native_auth_flutter_example" + compileSdk = flutter.compileSdkVersion + ndkVersion = flutter.ndkVersion + + compileOptions { + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 + } + + kotlinOptions { + jvmTarget = JavaVersion.VERSION_1_8 + } + + defaultConfig { + // TODO: Specify your own unique Application ID (https://developer.android.com/studio/build/application-id.html). + applicationId = "dev.celest.native_auth_flutter_example" + // You can update the following values to match your application needs. + // For more information, see: https://flutter.dev/to/review-gradle-config. + minSdk = flutter.minSdkVersion + targetSdk = flutter.targetSdkVersion + versionCode = flutter.versionCode + versionName = flutter.versionName + + manifestPlaceholders["nativeAuthRedirectScheme"] = "celest" + } + + buildTypes { + release { + // TODO: Add your own signing config for the release build. + // Signing with the debug keys for now, so `flutter run --release` works. + signingConfig = signingConfigs.debug + } + } +} + +flutter { + source = "../.." +} + +dependencies { + implementation "androidx.browser:browser:1.8.0" +} diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/debug/AndroidManifest.xml b/packages/native/auth/native_auth_flutter/example/android/app/src/debug/AndroidManifest.xml new file mode 100644 index 0000000..399f698 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/app/src/debug/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/AndroidManifest.xml b/packages/native/auth/native_auth_flutter/example/android/app/src/main/AndroidManifest.xml new file mode 100644 index 0000000..c8e461b --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/app/src/main/AndroidManifest.xml @@ -0,0 +1,46 @@ + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/kotlin/dev/celest/native_auth_flutter_example/MainActivity.kt b/packages/native/auth/native_auth_flutter/example/android/app/src/main/kotlin/dev/celest/native_auth_flutter_example/MainActivity.kt new file mode 100644 index 0000000..bab83e8 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/app/src/main/kotlin/dev/celest/native_auth_flutter_example/MainActivity.kt @@ -0,0 +1,17 @@ +package dev.celest.native_auth_flutter_example + +import android.content.Intent +import io.flutter.Log +import io.flutter.embedding.android.FlutterActivity + +class MainActivity: FlutterActivity() { + override fun onNewIntent(intent: Intent) { + super.onNewIntent(intent) + Log.i("MainActivity", "onNewIntent: $intent") + } + + override fun onResume() { + super.onResume() + Log.i("MainActivity", "onResume: $intent") + } +} diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/drawable-v21/launch_background.xml b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/drawable-v21/launch_background.xml new file mode 100644 index 0000000..f74085f --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/drawable-v21/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/drawable/launch_background.xml b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/drawable/launch_background.xml new file mode 100644 index 0000000..304732f --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/drawable/launch_background.xml @@ -0,0 +1,12 @@ + + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-hdpi/ic_launcher.png b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-hdpi/ic_launcher.png new file mode 100644 index 0000000..db77bb4 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-hdpi/ic_launcher.png differ diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-mdpi/ic_launcher.png b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-mdpi/ic_launcher.png new file mode 100644 index 0000000..17987b7 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-mdpi/ic_launcher.png differ diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png new file mode 100644 index 0000000..09d4391 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-xhdpi/ic_launcher.png differ diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png new file mode 100644 index 0000000..d5f1c8d Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-xxhdpi/ic_launcher.png differ diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png new file mode 100644 index 0000000..4d6372e Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/mipmap-xxxhdpi/ic_launcher.png differ diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/values-night/styles.xml b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/values-night/styles.xml new file mode 100644 index 0000000..06952be --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/values-night/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/values/styles.xml b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/values/styles.xml new file mode 100644 index 0000000..cb1ef88 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/app/src/main/res/values/styles.xml @@ -0,0 +1,18 @@ + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/android/app/src/profile/AndroidManifest.xml b/packages/native/auth/native_auth_flutter/example/android/app/src/profile/AndroidManifest.xml new file mode 100644 index 0000000..399f698 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/app/src/profile/AndroidManifest.xml @@ -0,0 +1,7 @@ + + + + diff --git a/packages/native/auth/native_auth_flutter/example/android/build.gradle b/packages/native/auth/native_auth_flutter/example/android/build.gradle new file mode 100644 index 0000000..d2ffbff --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/build.gradle @@ -0,0 +1,18 @@ +allprojects { + repositories { + google() + mavenCentral() + } +} + +rootProject.buildDir = "../build" +subprojects { + project.buildDir = "${rootProject.buildDir}/${project.name}" +} +subprojects { + project.evaluationDependsOn(":app") +} + +tasks.register("clean", Delete) { + delete rootProject.buildDir +} diff --git a/packages/native/auth/native_auth_flutter/example/android/gradle.properties b/packages/native/auth/native_auth_flutter/example/android/gradle.properties new file mode 100644 index 0000000..db24e8b --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/gradle.properties @@ -0,0 +1,6 @@ +org.gradle.jvmargs=-Xmx4G -XX:MaxMetaspaceSize=2G -XX:+HeapDumpOnOutOfMemoryError +android.useAndroidX=true +android.enableJetifier=true +android.defaults.buildfeatures.buildconfig=true +android.nonTransitiveRClass=false +android.nonFinalResIds=false diff --git a/packages/native/auth/native_auth_flutter/example/android/gradle/wrapper/gradle-wrapper.properties b/packages/native/auth/native_auth_flutter/example/android/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..3c85cfe --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-8.7-all.zip diff --git a/packages/native/auth/native_auth_flutter/example/android/settings.gradle b/packages/native/auth/native_auth_flutter/example/android/settings.gradle new file mode 100644 index 0000000..64d25b7 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/android/settings.gradle @@ -0,0 +1,25 @@ +pluginManagement { + def flutterSdkPath = { + def properties = new Properties() + file("local.properties").withInputStream { properties.load(it) } + def flutterSdkPath = properties.getProperty("flutter.sdk") + assert flutterSdkPath != null, "flutter.sdk not set in local.properties" + return flutterSdkPath + }() + + includeBuild("$flutterSdkPath/packages/flutter_tools/gradle") + + repositories { + google() + mavenCentral() + gradlePluginPortal() + } +} + +plugins { + id "dev.flutter.flutter-plugin-loader" version "1.0.0" + id "com.android.application" version '8.5.1' apply false + id "org.jetbrains.kotlin.android" version "1.7.10" apply false +} + +include ":app" diff --git a/packages/native/auth/native_auth_flutter/example/ios/.gitignore b/packages/native/auth/native_auth_flutter/example/ios/.gitignore new file mode 100644 index 0000000..7a7f987 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/.gitignore @@ -0,0 +1,34 @@ +**/dgph +*.mode1v3 +*.mode2v3 +*.moved-aside +*.pbxuser +*.perspectivev3 +**/*sync/ +.sconsign.dblite +.tags* +**/.vagrant/ +**/DerivedData/ +Icon? +**/Pods/ +**/.symlinks/ +profile +xcuserdata +**/.generated/ +Flutter/App.framework +Flutter/Flutter.framework +Flutter/Flutter.podspec +Flutter/Generated.xcconfig +Flutter/ephemeral/ +Flutter/app.flx +Flutter/app.zip +Flutter/flutter_assets/ +Flutter/flutter_export_environment.sh +ServiceDefinitions.json +Runner/GeneratedPluginRegistrant.* + +# Exceptions to above rules. +!default.mode1v3 +!default.mode2v3 +!default.pbxuser +!default.perspectivev3 diff --git a/packages/native/auth/native_auth_flutter/example/ios/Flutter/AppFrameworkInfo.plist b/packages/native/auth/native_auth_flutter/example/ios/Flutter/AppFrameworkInfo.plist new file mode 100644 index 0000000..7c56964 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Flutter/AppFrameworkInfo.plist @@ -0,0 +1,26 @@ + + + + + CFBundleDevelopmentRegion + en + CFBundleExecutable + App + CFBundleIdentifier + io.flutter.flutter.app + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + App + CFBundlePackageType + FMWK + CFBundleShortVersionString + 1.0 + CFBundleSignature + ???? + CFBundleVersion + 1.0 + MinimumOSVersion + 12.0 + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Flutter/Debug.xcconfig b/packages/native/auth/native_auth_flutter/example/ios/Flutter/Debug.xcconfig new file mode 100644 index 0000000..ec97fc6 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Flutter/Debug.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig" +#include "Generated.xcconfig" diff --git a/packages/native/auth/native_auth_flutter/example/ios/Flutter/Release.xcconfig b/packages/native/auth/native_auth_flutter/example/ios/Flutter/Release.xcconfig new file mode 100644 index 0000000..c4855bf --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Flutter/Release.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig" +#include "Generated.xcconfig" diff --git a/packages/native/auth/native_auth_flutter/example/ios/Podfile b/packages/native/auth/native_auth_flutter/example/ios/Podfile new file mode 100644 index 0000000..ebaf318 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Podfile @@ -0,0 +1,43 @@ +platform :ios, '13.0' + +# CocoaPods analytics sends network stats synchronously affecting flutter build latency. +ENV['COCOAPODS_DISABLE_STATS'] = 'true' + +project 'Runner', { + 'Debug' => :debug, + 'Profile' => :release, + 'Release' => :release, +} + +def flutter_root + generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'Generated.xcconfig'), __FILE__) + unless File.exist?(generated_xcode_build_settings_path) + raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure flutter pub get is executed first" + end + + File.foreach(generated_xcode_build_settings_path) do |line| + matches = line.match(/FLUTTER_ROOT\=(.*)/) + return matches[1].strip if matches + end + raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Generated.xcconfig, then run flutter pub get" +end + +require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root) + +flutter_ios_podfile_setup + +target 'Runner' do + use_frameworks! + use_modular_headers! + + flutter_install_all_ios_pods File.dirname(File.realpath(__FILE__)) + target 'RunnerTests' do + inherit! :search_paths + end +end + +post_install do |installer| + installer.pods_project.targets.each do |target| + flutter_additional_ios_build_settings(target) + end +end diff --git a/packages/native/auth/native_auth_flutter/example/ios/Podfile.lock b/packages/native/auth/native_auth_flutter/example/ios/Podfile.lock new file mode 100644 index 0000000..04f8412 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Podfile.lock @@ -0,0 +1,34 @@ +PODS: + - Flutter (1.0.0) + - native_auth_flutter (0.0.1): + - Flutter + - objective_c (0.0.1): + - Flutter + - url_launcher_ios (0.0.1): + - Flutter + +DEPENDENCIES: + - Flutter (from `Flutter`) + - native_auth_flutter (from `.symlinks/plugins/native_auth_flutter/ios`) + - objective_c (from `.symlinks/plugins/objective_c/ios`) + - url_launcher_ios (from `.symlinks/plugins/url_launcher_ios/ios`) + +EXTERNAL SOURCES: + Flutter: + :path: Flutter + native_auth_flutter: + :path: ".symlinks/plugins/native_auth_flutter/ios" + objective_c: + :path: ".symlinks/plugins/objective_c/ios" + url_launcher_ios: + :path: ".symlinks/plugins/url_launcher_ios/ios" + +SPEC CHECKSUMS: + Flutter: e0871f40cf51350855a761d2e70bf5af5b9b5de7 + native_auth_flutter: b37b7c26b3e93c5bf4e84c2c50a3b930e3c0710d + objective_c: aedd8e7e00e2d8940f8ff085155bb7727fa88e93 + url_launcher_ios: 5334b05cef931de560670eeae103fd3e431ac3fe + +PODFILE CHECKSUM: ade96bceabe3919b69c16573938e4268fe3a6c9d + +COCOAPODS: 1.15.2 diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.pbxproj b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.pbxproj new file mode 100644 index 0000000..7396205 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,733 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXBuildFile section */ + 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */ = {isa = PBXBuildFile; fileRef = 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */; }; + 331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C807B294A618700263BE5 /* RunnerTests.swift */; }; + 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; }; + 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; }; + 755C000A3D1A58205F98EB8A /* Pods_RunnerTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = BD70E37CCA71C8B644D009A2 /* Pods_RunnerTests.framework */; }; + 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; }; + 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; }; + 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; }; + FCF4878F8B3C8539136EA63B /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = AE5C86F2A0E2D715B4E63B12 /* Pods_Runner.framework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 331C8085294A63A400263BE5 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 97C146E61CF9000F007C117D /* Project object */; + proxyType = 1; + remoteGlobalIDString = 97C146ED1CF9000F007C117D; + remoteInfo = Runner; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 9705A1C41CF9048500538489 /* Embed Frameworks */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Embed Frameworks"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 06AAE91FFEB56C1E8422FF94 /* Pods-RunnerTests.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.profile.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.profile.xcconfig"; sourceTree = ""; }; + 13B23FABA705BBE078253414 /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = ""; }; + 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = GeneratedPluginRegistrant.h; sourceTree = ""; }; + 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = GeneratedPluginRegistrant.m; sourceTree = ""; }; + 331C807B294A618700263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = ""; }; + 331C8081294A63A400263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = ""; }; + 68F65A8A8D37EA1DB003C018 /* Pods-RunnerTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.release.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.release.xcconfig"; sourceTree = ""; }; + 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = ""; }; + 74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = ""; }; + 7CDDB39698AF7A1833DCB8DD /* Pods-RunnerTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.debug.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.debug.xcconfig"; sourceTree = ""; }; + 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = ""; }; + 9740EEB31CF90195004384FC /* Generated.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Generated.xcconfig; path = Flutter/Generated.xcconfig; sourceTree = ""; }; + 97C146EE1CF9000F007C117D /* Runner.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = Runner.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 97C146FB1CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/Main.storyboard; sourceTree = ""; }; + 97C146FD1CF9000F007C117D /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; path = Assets.xcassets; sourceTree = ""; }; + 97C147001CF9000F007C117D /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.storyboard; name = Base; path = Base.lproj/LaunchScreen.storyboard; sourceTree = ""; }; + 97C147021CF9000F007C117D /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = ""; }; + AE5C86F2A0E2D715B4E63B12 /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + B981195B8EEE46A41500520D /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = ""; }; + BD70E37CCA71C8B644D009A2 /* Pods_RunnerTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RunnerTests.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + D3B2EEB463D0F76D2B5DC935 /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 14CE3C1DF0E31FE5038C5E4E /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 755C000A3D1A58205F98EB8A /* Pods_RunnerTests.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 97C146EB1CF9000F007C117D /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + FCF4878F8B3C8539136EA63B /* Pods_Runner.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 00EDEFF10DFCBB5365714D62 /* Frameworks */ = { + isa = PBXGroup; + children = ( + AE5C86F2A0E2D715B4E63B12 /* Pods_Runner.framework */, + BD70E37CCA71C8B644D009A2 /* Pods_RunnerTests.framework */, + ); + name = Frameworks; + sourceTree = ""; + }; + 331C8082294A63A400263BE5 /* RunnerTests */ = { + isa = PBXGroup; + children = ( + 331C807B294A618700263BE5 /* RunnerTests.swift */, + ); + path = RunnerTests; + sourceTree = ""; + }; + 9740EEB11CF90186004384FC /* Flutter */ = { + isa = PBXGroup; + children = ( + 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */, + 9740EEB21CF90195004384FC /* Debug.xcconfig */, + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, + 9740EEB31CF90195004384FC /* Generated.xcconfig */, + ); + name = Flutter; + sourceTree = ""; + }; + 97C146E51CF9000F007C117D = { + isa = PBXGroup; + children = ( + 9740EEB11CF90186004384FC /* Flutter */, + 97C146F01CF9000F007C117D /* Runner */, + 97C146EF1CF9000F007C117D /* Products */, + 331C8082294A63A400263BE5 /* RunnerTests */, + F17F8DA562D4BE42B02841DA /* Pods */, + 00EDEFF10DFCBB5365714D62 /* Frameworks */, + ); + sourceTree = ""; + }; + 97C146EF1CF9000F007C117D /* Products */ = { + isa = PBXGroup; + children = ( + 97C146EE1CF9000F007C117D /* Runner.app */, + 331C8081294A63A400263BE5 /* RunnerTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 97C146F01CF9000F007C117D /* Runner */ = { + isa = PBXGroup; + children = ( + 97C146FA1CF9000F007C117D /* Main.storyboard */, + 97C146FD1CF9000F007C117D /* Assets.xcassets */, + 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */, + 97C147021CF9000F007C117D /* Info.plist */, + 1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */, + 1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */, + 74858FAE1ED2DC5600515810 /* AppDelegate.swift */, + 74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */, + ); + path = Runner; + sourceTree = ""; + }; + F17F8DA562D4BE42B02841DA /* Pods */ = { + isa = PBXGroup; + children = ( + B981195B8EEE46A41500520D /* Pods-Runner.debug.xcconfig */, + 13B23FABA705BBE078253414 /* Pods-Runner.release.xcconfig */, + D3B2EEB463D0F76D2B5DC935 /* Pods-Runner.profile.xcconfig */, + 7CDDB39698AF7A1833DCB8DD /* Pods-RunnerTests.debug.xcconfig */, + 68F65A8A8D37EA1DB003C018 /* Pods-RunnerTests.release.xcconfig */, + 06AAE91FFEB56C1E8422FF94 /* Pods-RunnerTests.profile.xcconfig */, + ); + path = Pods; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 331C8080294A63A400263BE5 /* RunnerTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */; + buildPhases = ( + 1F7FC5402E2515D3358A9DE4 /* [CP] Check Pods Manifest.lock */, + 331C807D294A63A400263BE5 /* Sources */, + 331C807F294A63A400263BE5 /* Resources */, + 14CE3C1DF0E31FE5038C5E4E /* Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + 331C8086294A63A400263BE5 /* PBXTargetDependency */, + ); + name = RunnerTests; + productName = RunnerTests; + productReference = 331C8081294A63A400263BE5 /* RunnerTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 97C146ED1CF9000F007C117D /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + A8457C6615F88D12CF39EED2 /* [CP] Check Pods Manifest.lock */, + 9740EEB61CF901F6004384FC /* Run Script */, + 97C146EA1CF9000F007C117D /* Sources */, + 97C146EB1CF9000F007C117D /* Frameworks */, + 97C146EC1CF9000F007C117D /* Resources */, + 9705A1C41CF9048500538489 /* Embed Frameworks */, + 3B06AD1E1E4923F5004D2608 /* Thin Binary */, + 641CFACC7221F67D1024F753 /* [CP] Embed Pods Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + ); + name = Runner; + productName = Runner; + productReference = 97C146EE1CF9000F007C117D /* Runner.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 97C146E61CF9000F007C117D /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastUpgradeCheck = 1510; + ORGANIZATIONNAME = ""; + TargetAttributes = { + 331C8080294A63A400263BE5 = { + CreatedOnToolsVersion = 14.0; + TestTargetID = 97C146ED1CF9000F007C117D; + }; + 97C146ED1CF9000F007C117D = { + CreatedOnToolsVersion = 7.3.1; + LastSwiftMigration = 1100; + }; + }; + }; + buildConfigurationList = 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 97C146E51CF9000F007C117D; + productRefGroup = 97C146EF1CF9000F007C117D /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 97C146ED1CF9000F007C117D /* Runner */, + 331C8080294A63A400263BE5 /* RunnerTests */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 331C807F294A63A400263BE5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 97C146EC1CF9000F007C117D /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */, + 3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */, + 97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */, + 97C146FC1CF9000F007C117D /* Main.storyboard in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 1F7FC5402E2515D3358A9DE4 /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-RunnerTests-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; + 3B06AD1E1E4923F5004D2608 /* Thin Binary */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + "${TARGET_BUILD_DIR}/${INFOPLIST_PATH}", + ); + name = "Thin Binary"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" embed_and_thin"; + }; + 641CFACC7221F67D1024F753 /* [CP] Embed Pods Frameworks */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist", + ); + name = "[CP] Embed Pods Frameworks"; + outputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n"; + showEnvVarsInLog = 0; + }; + 9740EEB61CF901F6004384FC /* Run Script */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputPaths = ( + ); + name = "Run Script"; + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "/bin/sh \"$FLUTTER_ROOT/packages/flutter_tools/bin/xcode_backend.sh\" build"; + }; + A8457C6615F88D12CF39EED2 /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-Runner-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 331C807D294A63A400263BE5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 331C808B294A63AB00263BE5 /* RunnerTests.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 97C146EA1CF9000F007C117D /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */, + 1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 331C8086294A63A400263BE5 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 97C146ED1CF9000F007C117D /* Runner */; + targetProxy = 331C8085294A63A400263BE5 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 97C146FA1CF9000F007C117D /* Main.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 97C146FB1CF9000F007C117D /* Base */, + ); + name = Main.storyboard; + sourceTree = ""; + }; + 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */ = { + isa = PBXVariantGroup; + children = ( + 97C147001CF9000F007C117D /* Base */, + ); + name = LaunchScreen.storyboard; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 249021D3217E4FDB00AE95B9 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + SUPPORTED_PLATFORMS = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Profile; + }; + 249021D4217E4FDB00AE95B9 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + DEVELOPMENT_TEAM = 3N44X5LWWW; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Profile; + }; + 331C8088294A63A400263BE5 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7CDDB39698AF7A1833DCB8DD /* Pods-RunnerTests.debug.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Debug; + }; + 331C8089294A63A400263BE5 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 68F65A8A8D37EA1DB003C018 /* Pods-RunnerTests.release.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Release; + }; + 331C808A294A63A400263BE5 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 06AAE91FFEB56C1E8422FF94 /* Pods-RunnerTests.profile.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CODE_SIGN_STYLE = Automatic; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/Runner.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/Runner"; + }; + name = Profile; + }; + 97C147031CF9000F007C117D /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = iphoneos; + TARGETED_DEVICE_FAMILY = "1,2"; + }; + name = Debug; + }; + 97C147041CF9000F007C117D /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_COMMA = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_STRICT_PROTOTYPES = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CLANG_WARN_UNREACHABLE_CODE = YES; + CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; + "CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "iPhone Developer"; + COPY_PHASE_STRIP = NO; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu99; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNDECLARED_SELECTOR = YES; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = iphoneos; + SUPPORTED_PLATFORMS = iphoneos; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + TARGETED_DEVICE_FAMILY = "1,2"; + VALIDATE_PRODUCT = YES; + }; + name = Release; + }; + 97C147061CF9000F007C117D /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + DEVELOPMENT_TEAM = 3N44X5LWWW; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Debug; + }; + 97C147071CF9000F007C117D /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CURRENT_PROJECT_VERSION = "$(FLUTTER_BUILD_NUMBER)"; + DEVELOPMENT_TEAM = 3N44X5LWWW; + ENABLE_BITCODE = NO; + INFOPLIST_FILE = Runner/Info.plist; + IPHONEOS_DEPLOYMENT_TARGET = 13.0; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/Frameworks", + ); + PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_OBJC_BRIDGING_HEADER = "Runner/Runner-Bridging-Header.h"; + SWIFT_VERSION = 5.0; + VERSIONING_SYSTEM = "apple-generic"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 331C8087294A63A400263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 331C8088294A63A400263BE5 /* Debug */, + 331C8089294A63A400263BE5 /* Release */, + 331C808A294A63A400263BE5 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 97C146E91CF9000F007C117D /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 97C147031CF9000F007C117D /* Debug */, + 97C147041CF9000F007C117D /* Release */, + 249021D3217E4FDB00AE95B9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 97C147051CF9000F007C117D /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 97C147061CF9000F007C117D /* Debug */, + 97C147071CF9000F007C117D /* Release */, + 249021D4217E4FDB00AE95B9 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 97C146E61CF9000F007C117D /* Project object */; +} diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..919434a --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,7 @@ + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings new file mode 100644 index 0000000..f9b0d7c --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/project.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings @@ -0,0 +1,8 @@ + + + + + PreviewsEnabled + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 0000000..8e3ca5d --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner.xcworkspace/contents.xcworkspacedata b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..21a3cc1 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,10 @@ + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings new file mode 100644 index 0000000..f9b0d7c --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner.xcworkspace/xcshareddata/WorkspaceSettings.xcsettings @@ -0,0 +1,8 @@ + + + + + PreviewsEnabled + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/AppDelegate.swift b/packages/native/auth/native_auth_flutter/example/ios/Runner/AppDelegate.swift new file mode 100644 index 0000000..6266644 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner/AppDelegate.swift @@ -0,0 +1,13 @@ +import Flutter +import UIKit + +@main +@objc class AppDelegate: FlutterAppDelegate { + override func application( + _ application: UIApplication, + didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]? + ) -> Bool { + GeneratedPluginRegistrant.register(with: self) + return super.application(application, didFinishLaunchingWithOptions: launchOptions) + } +} diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..d36b1fa --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,122 @@ +{ + "images" : [ + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-App-20x20@2x.png", + "scale" : "2x" + }, + { + "size" : "20x20", + "idiom" : "iphone", + "filename" : "Icon-App-20x20@3x.png", + "scale" : "3x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@1x.png", + "scale" : "1x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@2x.png", + "scale" : "2x" + }, + { + "size" : "29x29", + "idiom" : "iphone", + "filename" : "Icon-App-29x29@3x.png", + "scale" : "3x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-App-40x40@2x.png", + "scale" : "2x" + }, + { + "size" : "40x40", + "idiom" : "iphone", + "filename" : "Icon-App-40x40@3x.png", + "scale" : "3x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-App-60x60@2x.png", + "scale" : "2x" + }, + { + "size" : "60x60", + "idiom" : "iphone", + "filename" : "Icon-App-60x60@3x.png", + "scale" : "3x" + }, + { + "size" : "20x20", + "idiom" : "ipad", + "filename" : "Icon-App-20x20@1x.png", + "scale" : "1x" + }, + { + "size" : "20x20", + "idiom" : "ipad", + "filename" : "Icon-App-20x20@2x.png", + "scale" : "2x" + }, + { + "size" : "29x29", + "idiom" : "ipad", + "filename" : "Icon-App-29x29@1x.png", + "scale" : "1x" + }, + { + "size" : "29x29", + "idiom" : "ipad", + "filename" : "Icon-App-29x29@2x.png", + "scale" : "2x" + }, + { + "size" : "40x40", + "idiom" : "ipad", + "filename" : "Icon-App-40x40@1x.png", + "scale" : "1x" + }, + { + "size" : "40x40", + "idiom" : "ipad", + "filename" : "Icon-App-40x40@2x.png", + "scale" : "2x" + }, + { + "size" : "76x76", + "idiom" : "ipad", + "filename" : "Icon-App-76x76@1x.png", + "scale" : "1x" + }, + { + "size" : "76x76", + "idiom" : "ipad", + "filename" : "Icon-App-76x76@2x.png", + "scale" : "2x" + }, + { + "size" : "83.5x83.5", + "idiom" : "ipad", + "filename" : "Icon-App-83.5x83.5@2x.png", + "scale" : "2x" + }, + { + "size" : "1024x1024", + "idiom" : "ios-marketing", + "filename" : "Icon-App-1024x1024@1x.png", + "scale" : "1x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png new file mode 100644 index 0000000..dc9ada4 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-1024x1024@1x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png new file mode 100644 index 0000000..7353c41 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@1x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png new file mode 100644 index 0000000..797d452 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@2x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png new file mode 100644 index 0000000..6ed2d93 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-20x20@3x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png new file mode 100644 index 0000000..4cd7b00 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@1x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png new file mode 100644 index 0000000..fe73094 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@2x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png new file mode 100644 index 0000000..321773c Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-29x29@3x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png new file mode 100644 index 0000000..797d452 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@1x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png new file mode 100644 index 0000000..502f463 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@2x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png new file mode 100644 index 0000000..0ec3034 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-40x40@3x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png new file mode 100644 index 0000000..0ec3034 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@2x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png new file mode 100644 index 0000000..e9f5fea Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-60x60@3x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png new file mode 100644 index 0000000..84ac32a Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@1x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png new file mode 100644 index 0000000..8953cba Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-76x76@2x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png new file mode 100644 index 0000000..0467bf1 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/AppIcon.appiconset/Icon-App-83.5x83.5@2x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json new file mode 100644 index 0000000..0bedcf2 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/Contents.json @@ -0,0 +1,23 @@ +{ + "images" : [ + { + "idiom" : "universal", + "filename" : "LaunchImage.png", + "scale" : "1x" + }, + { + "idiom" : "universal", + "filename" : "LaunchImage@2x.png", + "scale" : "2x" + }, + { + "idiom" : "universal", + "filename" : "LaunchImage@3x.png", + "scale" : "3x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png new file mode 100644 index 0000000..9da19ea Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png new file mode 100644 index 0000000..9da19ea Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@2x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png new file mode 100644 index 0000000..9da19ea Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/LaunchImage@3x.png differ diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md new file mode 100644 index 0000000..89c2725 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner/Assets.xcassets/LaunchImage.imageset/README.md @@ -0,0 +1,5 @@ +# Launch Screen Assets + +You can customize the launch screen with your own desired assets by replacing the image files in this directory. + +You can also do it by opening your Flutter project's Xcode project with `open ios/Runner.xcworkspace`, selecting `Runner/Assets.xcassets` in the Project Navigator and dropping in the desired images. \ No newline at end of file diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Base.lproj/LaunchScreen.storyboard b/packages/native/auth/native_auth_flutter/example/ios/Runner/Base.lproj/LaunchScreen.storyboard new file mode 100644 index 0000000..f2e259c --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner/Base.lproj/LaunchScreen.storyboard @@ -0,0 +1,37 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Base.lproj/Main.storyboard b/packages/native/auth/native_auth_flutter/example/ios/Runner/Base.lproj/Main.storyboard new file mode 100644 index 0000000..f3c2851 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner/Base.lproj/Main.storyboard @@ -0,0 +1,26 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Info.plist b/packages/native/auth/native_auth_flutter/example/ios/Runner/Info.plist new file mode 100644 index 0000000..af6c996 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner/Info.plist @@ -0,0 +1,49 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleDisplayName + Native Auth Flutter + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + native_auth_flutter_example + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleSignature + ???? + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + LSRequiresIPhoneOS + + UILaunchStoryboardName + LaunchScreen + UIMainStoryboardFile + Main + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + CADisableMinimumFrameDurationOnPhone + + UIApplicationSupportsIndirectInputEvents + + + diff --git a/packages/native/auth/native_auth_flutter/example/ios/Runner/Runner-Bridging-Header.h b/packages/native/auth/native_auth_flutter/example/ios/Runner/Runner-Bridging-Header.h new file mode 100644 index 0000000..308a2a5 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/Runner/Runner-Bridging-Header.h @@ -0,0 +1 @@ +#import "GeneratedPluginRegistrant.h" diff --git a/packages/native/auth/native_auth_flutter/example/ios/RunnerTests/RunnerTests.swift b/packages/native/auth/native_auth_flutter/example/ios/RunnerTests/RunnerTests.swift new file mode 100644 index 0000000..86a7c3b --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/ios/RunnerTests/RunnerTests.swift @@ -0,0 +1,12 @@ +import Flutter +import UIKit +import XCTest + +class RunnerTests: XCTestCase { + + func testExample() { + // If you add code to the Runner application, consider adding tests here. + // See https://developer.apple.com/documentation/xctest for more information about using XCTest. + } + +} diff --git a/packages/native/auth/native_auth_flutter/example/lib/main.dart b/packages/native/auth/native_auth_flutter/example/lib/main.dart new file mode 100644 index 0000000..3a772d2 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/lib/main.dart @@ -0,0 +1,145 @@ +import 'dart:developer'; +import 'dart:io'; + +import 'package:flutter/material.dart'; +import 'package:logging/logging.dart'; +import 'package:native_auth_flutter/native_auth_flutter.dart'; + +late NativeAuth auth; + +void main() { + Logger.root.level = Level.ALL; + Logger.root.onRecord.listen((record) { + log( + record.message, + level: record.level.value, + name: record.loggerName, + ); + }); + auth = NativeAuth( + logger: Logger.root, + ); + runApp(const MyApp()); +} + +class MyApp extends StatefulWidget { + const MyApp({super.key}); + + @override + State createState() => _MyAppState(); +} + +class _MyAppState extends State { + @override + void initState() { + super.initState(); + } + + Future _result = Future.value('signed out'); + + Future _signIn() async { + setState(() { + _result = auth + .performAuthorizationRedirect( + uri: Uri( + scheme: 'https', + host: 'zitadel.celest-dev.dev', + path: '/oauth/v2/authorize', + queryParameters: { + 'client_id': '280077261611297625@test_app', + 'response_type': 'code', + 'redirect_uri': switch (Platform.operatingSystem) { + 'ios' || 'android' => 'celest://auth', + _ => 'http://localhost:7777/callback', + }, + 'scope': 'openid profile email offline_access', + }, + ), + callbackScheme: switch (Platform.operatingSystem) { + 'ios' || 'android' => const CallbackScheme.custom('celest'), + _ => const CallbackScheme.localhost( + port: 7777, + path: '/callback', + ), + }, + ) + .then((uri) => uri.toString()); + }); + } + + Future _signOut() async { + setState(() { + _result = auth + .performAuthorizationRedirect( + uri: Uri( + scheme: 'https', + host: 'zitadel.celest-dev.dev', + path: '/oidc/v1/end_session', + queryParameters: { + 'client_id': '280077261611297625@test_app', + 'post_logout_redirect_uri': switch (Platform.operatingSystem) { + 'ios' || 'android' => 'celest://auth', + _ => 'http://localhost:7777/callback', + }, + }, + ), + callbackScheme: switch (Platform.operatingSystem) { + 'ios' || 'android' => const CallbackScheme.custom('celest'), + _ => const CallbackScheme.localhost( + port: 7777, + path: '/callback', + ), + }, + ) + .then((_) => 'signed out'); + }); + } + + @override + Widget build(BuildContext context) { + const textStyle = TextStyle(fontSize: 25); + const spacerSmall = SizedBox(height: 10); + return MaterialApp( + home: Scaffold( + appBar: AppBar( + title: const Text('Native Auth'), + ), + body: Center( + child: Container( + padding: const EdgeInsets.all(10), + child: Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + ElevatedButton( + onPressed: _signIn, + child: const Text('SIGN IN'), + ), + spacerSmall, + ElevatedButton( + onPressed: _signOut, + child: const Text('SIGN OUT'), + ), + spacerSmall, + FutureBuilder( + future: _result, + builder: (BuildContext context, AsyncSnapshot value) { + final displayValue = (value.hasData) + ? value.data + : value.hasError + ? '${value.error}' + : 'loading'; + return Text( + 'result = $displayValue', + style: textStyle, + textAlign: TextAlign.center, + ); + }, + ), + ], + ), + ), + ), + ), + ); + } +} diff --git a/packages/native/auth/native_auth_flutter/example/linux/.gitignore b/packages/native/auth/native_auth_flutter/example/linux/.gitignore new file mode 100644 index 0000000..d3896c9 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/linux/.gitignore @@ -0,0 +1 @@ +flutter/ephemeral diff --git a/packages/native/auth/native_auth_flutter/example/linux/CMakeLists.txt b/packages/native/auth/native_auth_flutter/example/linux/CMakeLists.txt new file mode 100644 index 0000000..c415f53 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/linux/CMakeLists.txt @@ -0,0 +1,145 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.10) +project(runner LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "example") +# The unique GTK application identifier for this application. See: +# https://wiki.gnome.org/HowDoI/ChooseApplicationID +set(APPLICATION_ID "dev.celest.example") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(SET CMP0063 NEW) + +# Load bundled libraries from the lib/ directory relative to the binary. +set(CMAKE_INSTALL_RPATH "$ORIGIN/lib") + +# Root filesystem for cross-building. +if(FLUTTER_TARGET_PLATFORM_SYSROOT) + set(CMAKE_SYSROOT ${FLUTTER_TARGET_PLATFORM_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH ${CMAKE_SYSROOT}) + set(CMAKE_FIND_ROOT_PATH_MODE_PROGRAM NEVER) + set(CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY) + set(CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY) +endif() + +# Define build configuration options. +if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") +endif() + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_14) + target_compile_options(${TARGET} PRIVATE -Wall -Werror) + target_compile_options(${TARGET} PRIVATE "$<$>:-O3>") + target_compile_definitions(${TARGET} PRIVATE "$<$>:NDEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) + +add_definitions(-DAPPLICATION_ID="${APPLICATION_ID}") + +# Define the application target. To change its name, change BINARY_NAME above, +# not the value here, or `flutter run` will no longer work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} + "main.cc" + "my_application.cc" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add dependency libraries. Add any application-specific dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter) +target_link_libraries(${BINARY_NAME} PRIVATE PkgConfig::GTK) + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) + +# Only the install-generated bundle's copy of the executable will launch +# correctly, since the resources must in the right relative locations. To avoid +# people trying to run the unbundled copy, put it in a subdirectory instead of +# the default top-level location. +set_target_properties(${BINARY_NAME} + PROPERTIES + RUNTIME_OUTPUT_DIRECTORY "${CMAKE_BINARY_DIR}/intermediates_do_not_run" +) + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# By default, "installing" just makes a relocatable bundle in the build +# directory. +set(BUILD_BUNDLE_DIR "${PROJECT_BINARY_DIR}/bundle") +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +# Start with a clean build bundle directory every time. +install(CODE " + file(REMOVE_RECURSE \"${BUILD_BUNDLE_DIR}/\") + " COMPONENT Runtime) + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}/lib") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +foreach(bundled_library ${PLUGIN_BUNDLED_LIBRARIES}) + install(FILES "${bundled_library}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endforeach(bundled_library) + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/linux/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +if(NOT CMAKE_BUILD_TYPE MATCHES "Debug") + install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() diff --git a/packages/native/auth/native_auth_flutter/example/linux/flutter/CMakeLists.txt b/packages/native/auth/native_auth_flutter/example/linux/flutter/CMakeLists.txt new file mode 100644 index 0000000..d5bd016 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/linux/flutter/CMakeLists.txt @@ -0,0 +1,88 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.10) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. + +# Serves the same purpose as list(TRANSFORM ... PREPEND ...), +# which isn't available in 3.10. +function(list_prepend LIST_NAME PREFIX) + set(NEW_LIST "") + foreach(element ${${LIST_NAME}}) + list(APPEND NEW_LIST "${PREFIX}${element}") + endforeach(element) + set(${LIST_NAME} "${NEW_LIST}" PARENT_SCOPE) +endfunction() + +# === Flutter Library === +# System-level dependencies. +find_package(PkgConfig REQUIRED) +pkg_check_modules(GTK REQUIRED IMPORTED_TARGET gtk+-3.0) +pkg_check_modules(GLIB REQUIRED IMPORTED_TARGET glib-2.0) +pkg_check_modules(GIO REQUIRED IMPORTED_TARGET gio-2.0) + +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/libflutter_linux_gtk.so") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/lib/libapp.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "fl_basic_message_channel.h" + "fl_binary_codec.h" + "fl_binary_messenger.h" + "fl_dart_project.h" + "fl_engine.h" + "fl_json_message_codec.h" + "fl_json_method_codec.h" + "fl_message_codec.h" + "fl_method_call.h" + "fl_method_channel.h" + "fl_method_codec.h" + "fl_method_response.h" + "fl_plugin_registrar.h" + "fl_plugin_registry.h" + "fl_standard_message_codec.h" + "fl_standard_method_codec.h" + "fl_string_codec.h" + "fl_value.h" + "fl_view.h" + "flutter_linux.h" +) +list_prepend(FLUTTER_LIBRARY_HEADERS "${EPHEMERAL_DIR}/flutter_linux/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}") +target_link_libraries(flutter INTERFACE + PkgConfig::GTK + PkgConfig::GLIB + PkgConfig::GIO +) +add_dependencies(flutter flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CMAKE_CURRENT_BINARY_DIR}/_phony_ + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.sh" + ${FLUTTER_TARGET_PLATFORM} ${CMAKE_BUILD_TYPE} + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} +) diff --git a/packages/native/auth/native_auth_flutter/example/linux/flutter/generated_plugin_registrant.cc b/packages/native/auth/native_auth_flutter/example/linux/flutter/generated_plugin_registrant.cc new file mode 100644 index 0000000..e71a16d --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/linux/flutter/generated_plugin_registrant.cc @@ -0,0 +1,11 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#include "generated_plugin_registrant.h" + + +void fl_register_plugins(FlPluginRegistry* registry) { +} diff --git a/packages/native/auth/native_auth_flutter/example/linux/flutter/generated_plugin_registrant.h b/packages/native/auth/native_auth_flutter/example/linux/flutter/generated_plugin_registrant.h new file mode 100644 index 0000000..e0f0a47 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/linux/flutter/generated_plugin_registrant.h @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GENERATED_PLUGIN_REGISTRANT_ +#define GENERATED_PLUGIN_REGISTRANT_ + +#include + +// Registers Flutter plugins. +void fl_register_plugins(FlPluginRegistry* registry); + +#endif // GENERATED_PLUGIN_REGISTRANT_ diff --git a/packages/native/auth/native_auth_flutter/example/linux/flutter/generated_plugins.cmake b/packages/native/auth/native_auth_flutter/example/linux/flutter/generated_plugins.cmake new file mode 100644 index 0000000..be1ee3e --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/linux/flutter/generated_plugins.cmake @@ -0,0 +1,24 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST + jni +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/linux plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/linux plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/packages/native/auth/native_auth_flutter/example/linux/main.cc b/packages/native/auth/native_auth_flutter/example/linux/main.cc new file mode 100644 index 0000000..e7c5c54 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/linux/main.cc @@ -0,0 +1,6 @@ +#include "my_application.h" + +int main(int argc, char** argv) { + g_autoptr(MyApplication) app = my_application_new(); + return g_application_run(G_APPLICATION(app), argc, argv); +} diff --git a/packages/native/auth/native_auth_flutter/example/linux/my_application.cc b/packages/native/auth/native_auth_flutter/example/linux/my_application.cc new file mode 100644 index 0000000..c0530d4 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/linux/my_application.cc @@ -0,0 +1,124 @@ +#include "my_application.h" + +#include +#ifdef GDK_WINDOWING_X11 +#include +#endif + +#include "flutter/generated_plugin_registrant.h" + +struct _MyApplication { + GtkApplication parent_instance; + char** dart_entrypoint_arguments; +}; + +G_DEFINE_TYPE(MyApplication, my_application, GTK_TYPE_APPLICATION) + +// Implements GApplication::activate. +static void my_application_activate(GApplication* application) { + MyApplication* self = MY_APPLICATION(application); + GtkWindow* window = + GTK_WINDOW(gtk_application_window_new(GTK_APPLICATION(application))); + + // Use a header bar when running in GNOME as this is the common style used + // by applications and is the setup most users will be using (e.g. Ubuntu + // desktop). + // If running on X and not using GNOME then just use a traditional title bar + // in case the window manager does more exotic layout, e.g. tiling. + // If running on Wayland assume the header bar will work (may need changing + // if future cases occur). + gboolean use_header_bar = TRUE; +#ifdef GDK_WINDOWING_X11 + GdkScreen* screen = gtk_window_get_screen(window); + if (GDK_IS_X11_SCREEN(screen)) { + const gchar* wm_name = gdk_x11_screen_get_window_manager_name(screen); + if (g_strcmp0(wm_name, "GNOME Shell") != 0) { + use_header_bar = FALSE; + } + } +#endif + if (use_header_bar) { + GtkHeaderBar* header_bar = GTK_HEADER_BAR(gtk_header_bar_new()); + gtk_widget_show(GTK_WIDGET(header_bar)); + gtk_header_bar_set_title(header_bar, "example"); + gtk_header_bar_set_show_close_button(header_bar, TRUE); + gtk_window_set_titlebar(window, GTK_WIDGET(header_bar)); + } else { + gtk_window_set_title(window, "example"); + } + + gtk_window_set_default_size(window, 1280, 720); + gtk_widget_show(GTK_WIDGET(window)); + + g_autoptr(FlDartProject) project = fl_dart_project_new(); + fl_dart_project_set_dart_entrypoint_arguments(project, self->dart_entrypoint_arguments); + + FlView* view = fl_view_new(project); + gtk_widget_show(GTK_WIDGET(view)); + gtk_container_add(GTK_CONTAINER(window), GTK_WIDGET(view)); + + fl_register_plugins(FL_PLUGIN_REGISTRY(view)); + + gtk_widget_grab_focus(GTK_WIDGET(view)); +} + +// Implements GApplication::local_command_line. +static gboolean my_application_local_command_line(GApplication* application, gchar*** arguments, int* exit_status) { + MyApplication* self = MY_APPLICATION(application); + // Strip out the first argument as it is the binary name. + self->dart_entrypoint_arguments = g_strdupv(*arguments + 1); + + g_autoptr(GError) error = nullptr; + if (!g_application_register(application, nullptr, &error)) { + g_warning("Failed to register: %s", error->message); + *exit_status = 1; + return TRUE; + } + + g_application_activate(application); + *exit_status = 0; + + return TRUE; +} + +// Implements GApplication::startup. +static void my_application_startup(GApplication* application) { + //MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application startup. + + G_APPLICATION_CLASS(my_application_parent_class)->startup(application); +} + +// Implements GApplication::shutdown. +static void my_application_shutdown(GApplication* application) { + //MyApplication* self = MY_APPLICATION(object); + + // Perform any actions required at application shutdown. + + G_APPLICATION_CLASS(my_application_parent_class)->shutdown(application); +} + +// Implements GObject::dispose. +static void my_application_dispose(GObject* object) { + MyApplication* self = MY_APPLICATION(object); + g_clear_pointer(&self->dart_entrypoint_arguments, g_strfreev); + G_OBJECT_CLASS(my_application_parent_class)->dispose(object); +} + +static void my_application_class_init(MyApplicationClass* klass) { + G_APPLICATION_CLASS(klass)->activate = my_application_activate; + G_APPLICATION_CLASS(klass)->local_command_line = my_application_local_command_line; + G_APPLICATION_CLASS(klass)->startup = my_application_startup; + G_APPLICATION_CLASS(klass)->shutdown = my_application_shutdown; + G_OBJECT_CLASS(klass)->dispose = my_application_dispose; +} + +static void my_application_init(MyApplication* self) {} + +MyApplication* my_application_new() { + return MY_APPLICATION(g_object_new(my_application_get_type(), + "application-id", APPLICATION_ID, + "flags", G_APPLICATION_NON_UNIQUE, + nullptr)); +} diff --git a/packages/native/auth/native_auth_flutter/example/linux/my_application.h b/packages/native/auth/native_auth_flutter/example/linux/my_application.h new file mode 100644 index 0000000..72271d5 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/linux/my_application.h @@ -0,0 +1,18 @@ +#ifndef FLUTTER_MY_APPLICATION_H_ +#define FLUTTER_MY_APPLICATION_H_ + +#include + +G_DECLARE_FINAL_TYPE(MyApplication, my_application, MY, APPLICATION, + GtkApplication) + +/** + * my_application_new: + * + * Creates a new Flutter-based application. + * + * Returns: a new #MyApplication. + */ +MyApplication* my_application_new(); + +#endif // FLUTTER_MY_APPLICATION_H_ diff --git a/packages/native/auth/native_auth_flutter/example/macos/.gitignore b/packages/native/auth/native_auth_flutter/example/macos/.gitignore new file mode 100644 index 0000000..746adbb --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/.gitignore @@ -0,0 +1,7 @@ +# Flutter-related +**/Flutter/ephemeral/ +**/Pods/ + +# Xcode-related +**/dgph +**/xcuserdata/ diff --git a/packages/native/auth/native_auth_flutter/example/macos/Flutter/Flutter-Debug.xcconfig b/packages/native/auth/native_auth_flutter/example/macos/Flutter/Flutter-Debug.xcconfig new file mode 100644 index 0000000..4b81f9b --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Flutter/Flutter-Debug.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig" +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/packages/native/auth/native_auth_flutter/example/macos/Flutter/Flutter-Release.xcconfig b/packages/native/auth/native_auth_flutter/example/macos/Flutter/Flutter-Release.xcconfig new file mode 100644 index 0000000..5caa9d1 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Flutter/Flutter-Release.xcconfig @@ -0,0 +1,2 @@ +#include? "Pods/Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig" +#include "ephemeral/Flutter-Generated.xcconfig" diff --git a/packages/native/auth/native_auth_flutter/example/macos/Flutter/GeneratedPluginRegistrant.swift b/packages/native/auth/native_auth_flutter/example/macos/Flutter/GeneratedPluginRegistrant.swift new file mode 100644 index 0000000..cccf817 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Flutter/GeneratedPluginRegistrant.swift @@ -0,0 +1,10 @@ +// +// Generated file. Do not edit. +// + +import FlutterMacOS +import Foundation + + +func RegisterGeneratedPlugins(registry: FlutterPluginRegistry) { +} diff --git a/packages/native/auth/native_auth_flutter/example/macos/Podfile b/packages/native/auth/native_auth_flutter/example/macos/Podfile new file mode 100644 index 0000000..b52666a --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Podfile @@ -0,0 +1,43 @@ +platform :osx, '10.15' + +# CocoaPods analytics sends network stats synchronously affecting flutter build latency. +ENV['COCOAPODS_DISABLE_STATS'] = 'true' + +project 'Runner', { + 'Debug' => :debug, + 'Profile' => :release, + 'Release' => :release, +} + +def flutter_root + generated_xcode_build_settings_path = File.expand_path(File.join('..', 'Flutter', 'ephemeral', 'Flutter-Generated.xcconfig'), __FILE__) + unless File.exist?(generated_xcode_build_settings_path) + raise "#{generated_xcode_build_settings_path} must exist. If you're running pod install manually, make sure \"flutter pub get\" is executed first" + end + + File.foreach(generated_xcode_build_settings_path) do |line| + matches = line.match(/FLUTTER_ROOT\=(.*)/) + return matches[1].strip if matches + end + raise "FLUTTER_ROOT not found in #{generated_xcode_build_settings_path}. Try deleting Flutter-Generated.xcconfig, then run \"flutter pub get\"" +end + +require File.expand_path(File.join('packages', 'flutter_tools', 'bin', 'podhelper'), flutter_root) + +flutter_macos_podfile_setup + +target 'Runner' do + use_frameworks! + use_modular_headers! + + flutter_install_all_macos_pods File.dirname(File.realpath(__FILE__)) + target 'RunnerTests' do + inherit! :search_paths + end +end + +post_install do |installer| + installer.pods_project.targets.each do |target| + flutter_additional_macos_build_settings(target) + end +end diff --git a/packages/native/auth/native_auth_flutter/example/macos/Podfile.lock b/packages/native/auth/native_auth_flutter/example/macos/Podfile.lock new file mode 100644 index 0000000..45beba1 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Podfile.lock @@ -0,0 +1,34 @@ +PODS: + - FlutterMacOS (1.0.0) + - native_auth_flutter (0.0.1): + - FlutterMacOS + - objective_c (0.0.1): + - FlutterMacOS + - url_launcher_macos (0.0.1): + - FlutterMacOS + +DEPENDENCIES: + - FlutterMacOS (from `Flutter/ephemeral`) + - native_auth_flutter (from `Flutter/ephemeral/.symlinks/plugins/native_auth_flutter/macos`) + - objective_c (from `Flutter/ephemeral/.symlinks/plugins/objective_c/macos`) + - url_launcher_macos (from `Flutter/ephemeral/.symlinks/plugins/url_launcher_macos/macos`) + +EXTERNAL SOURCES: + FlutterMacOS: + :path: Flutter/ephemeral + native_auth_flutter: + :path: Flutter/ephemeral/.symlinks/plugins/native_auth_flutter/macos + objective_c: + :path: Flutter/ephemeral/.symlinks/plugins/objective_c/macos + url_launcher_macos: + :path: Flutter/ephemeral/.symlinks/plugins/url_launcher_macos/macos + +SPEC CHECKSUMS: + FlutterMacOS: 8f6f14fa908a6fb3fba0cd85dbd81ec4b251fb24 + native_auth_flutter: ac526268fc3e6f76b9d0d48d1847baab3d509449 + objective_c: c13d3306e0fbf006bad001fd523e4bf8ebda8953 + url_launcher_macos: 5f437abeda8c85500ceb03f5c1938a8c5a705399 + +PODFILE CHECKSUM: 9ebaf0ce3d369aaa26a9ea0e159195ed94724cf3 + +COCOAPODS: 1.15.2 diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner.xcodeproj/project.pbxproj b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcodeproj/project.pbxproj new file mode 100644 index 0000000..d48150c --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcodeproj/project.pbxproj @@ -0,0 +1,809 @@ +// !$*UTF8*$! +{ + archiveVersion = 1; + classes = { + }; + objectVersion = 54; + objects = { + +/* Begin PBXAggregateTarget section */ + 33CC111A2044C6BA0003C045 /* Flutter Assemble */ = { + isa = PBXAggregateTarget; + buildConfigurationList = 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */; + buildPhases = ( + 33CC111E2044C6BF0003C045 /* ShellScript */, + ); + dependencies = ( + ); + name = "Flutter Assemble"; + productName = FLX; + }; +/* End PBXAggregateTarget section */ + +/* Begin PBXBuildFile section */ + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */ = {isa = PBXBuildFile; fileRef = 331C80D7294CF71000263BE5 /* RunnerTests.swift */; }; + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */ = {isa = PBXBuildFile; fileRef = 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */; }; + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC10F02044A3C60003C045 /* AppDelegate.swift */; }; + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F22044A3C60003C045 /* Assets.xcassets */; }; + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */ = {isa = PBXBuildFile; fileRef = 33CC10F42044A3C60003C045 /* MainMenu.xib */; }; + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */ = {isa = PBXBuildFile; fileRef = 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */; }; + 3601C5290BC5B2D2B4FD172A /* Pods_RunnerTests.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 0F2ED5785FC9F9FAE6F2EA75 /* Pods_RunnerTests.framework */; }; + D930A142CB5B72EE8CBD6ADB /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 15AA952EC1A4DDEC3A777BD3 /* Pods_Runner.framework */; }; +/* End PBXBuildFile section */ + +/* Begin PBXContainerItemProxy section */ + 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC10EC2044A3C60003C045; + remoteInfo = Runner; + }; + 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */ = { + isa = PBXContainerItemProxy; + containerPortal = 33CC10E52044A3C60003C045 /* Project object */; + proxyType = 1; + remoteGlobalIDString = 33CC111A2044C6BA0003C045; + remoteInfo = FLX; + }; +/* End PBXContainerItemProxy section */ + +/* Begin PBXCopyFilesBuildPhase section */ + 33CC110E2044A8840003C045 /* Bundle Framework */ = { + isa = PBXCopyFilesBuildPhase; + buildActionMask = 2147483647; + dstPath = ""; + dstSubfolderSpec = 10; + files = ( + ); + name = "Bundle Framework"; + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXCopyFilesBuildPhase section */ + +/* Begin PBXFileReference section */ + 0F2ED5785FC9F9FAE6F2EA75 /* Pods_RunnerTests.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_RunnerTests.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + 15AA952EC1A4DDEC3A777BD3 /* Pods_Runner.framework */ = {isa = PBXFileReference; explicitFileType = wrapper.framework; includeInIndex = 0; path = Pods_Runner.framework; sourceTree = BUILT_PRODUCTS_DIR; }; + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = RunnerTests.xctest; sourceTree = BUILT_PRODUCTS_DIR; }; + 331C80D7294CF71000263BE5 /* RunnerTests.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = RunnerTests.swift; sourceTree = ""; }; + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Warnings.xcconfig; sourceTree = ""; }; + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = GeneratedPluginRegistrant.swift; sourceTree = ""; }; + 33CC10ED2044A3C60003C045 /* native_auth_flutter_example.app */ = {isa = PBXFileReference; explicitFileType = wrapper.application; includeInIndex = 0; path = native_auth_flutter_example.app; sourceTree = BUILT_PRODUCTS_DIR; }; + 33CC10F02044A3C60003C045 /* AppDelegate.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = ""; }; + 33CC10F22044A3C60003C045 /* Assets.xcassets */ = {isa = PBXFileReference; lastKnownFileType = folder.assetcatalog; name = Assets.xcassets; path = Runner/Assets.xcassets; sourceTree = ""; }; + 33CC10F52044A3C60003C045 /* Base */ = {isa = PBXFileReference; lastKnownFileType = file.xib; name = Base; path = Base.lproj/MainMenu.xib; sourceTree = ""; }; + 33CC10F72044A3C60003C045 /* Info.plist */ = {isa = PBXFileReference; lastKnownFileType = text.plist.xml; name = Info.plist; path = Runner/Info.plist; sourceTree = ""; }; + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = MainFlutterWindow.swift; sourceTree = ""; }; + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Debug.xcconfig"; sourceTree = ""; }; + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = "Flutter-Release.xcconfig"; sourceTree = ""; }; + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = "Flutter-Generated.xcconfig"; path = "ephemeral/Flutter-Generated.xcconfig"; sourceTree = ""; }; + 33E51913231747F40026EE4D /* DebugProfile.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.plist.entitlements; path = DebugProfile.entitlements; sourceTree = ""; }; + 33E51914231749380026EE4D /* Release.entitlements */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.entitlements; path = Release.entitlements; sourceTree = ""; }; + 33E5194F232828860026EE4D /* AppInfo.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = AppInfo.xcconfig; sourceTree = ""; }; + 4E465E44A34B974D73E1D1D5 /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = ""; }; + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; path = Release.xcconfig; sourceTree = ""; }; + 7E92109DC1C25CBF7CEEAE7B /* Pods-RunnerTests.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.debug.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.debug.xcconfig"; sourceTree = ""; }; + 83EA378EFDF03C51D2D094F3 /* Pods-RunnerTests.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.release.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.release.xcconfig"; sourceTree = ""; }; + 9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; path = Debug.xcconfig; sourceTree = ""; }; + BBFCA5EC85DC6FE052392EAE /* Pods-Runner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.release.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.release.xcconfig"; sourceTree = ""; }; + E9AC8262B7AEAFCE85179156 /* Pods-RunnerTests.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-RunnerTests.profile.xcconfig"; path = "Target Support Files/Pods-RunnerTests/Pods-RunnerTests.profile.xcconfig"; sourceTree = ""; }; + EEACB20F2A301EC4C157C644 /* Pods-Runner.profile.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.profile.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.profile.xcconfig"; sourceTree = ""; }; +/* End PBXFileReference section */ + +/* Begin PBXFrameworksBuildPhase section */ + 331C80D2294CF70F00263BE5 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + 3601C5290BC5B2D2B4FD172A /* Pods_RunnerTests.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EA2044A3C60003C045 /* Frameworks */ = { + isa = PBXFrameworksBuildPhase; + buildActionMask = 2147483647; + files = ( + D930A142CB5B72EE8CBD6ADB /* Pods_Runner.framework in Frameworks */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXFrameworksBuildPhase section */ + +/* Begin PBXGroup section */ + 273427FD9215EDCCEE698DEE /* Pods */ = { + isa = PBXGroup; + children = ( + 4E465E44A34B974D73E1D1D5 /* Pods-Runner.debug.xcconfig */, + BBFCA5EC85DC6FE052392EAE /* Pods-Runner.release.xcconfig */, + EEACB20F2A301EC4C157C644 /* Pods-Runner.profile.xcconfig */, + 7E92109DC1C25CBF7CEEAE7B /* Pods-RunnerTests.debug.xcconfig */, + 83EA378EFDF03C51D2D094F3 /* Pods-RunnerTests.release.xcconfig */, + E9AC8262B7AEAFCE85179156 /* Pods-RunnerTests.profile.xcconfig */, + ); + path = Pods; + sourceTree = ""; + }; + 331C80D6294CF71000263BE5 /* RunnerTests */ = { + isa = PBXGroup; + children = ( + 331C80D7294CF71000263BE5 /* RunnerTests.swift */, + ); + path = RunnerTests; + sourceTree = ""; + }; + 33BA886A226E78AF003329D5 /* Configs */ = { + isa = PBXGroup; + children = ( + 33E5194F232828860026EE4D /* AppInfo.xcconfig */, + 9740EEB21CF90195004384FC /* Debug.xcconfig */, + 7AFA3C8E1D35360C0083082E /* Release.xcconfig */, + 333000ED22D3DE5D00554162 /* Warnings.xcconfig */, + ); + path = Configs; + sourceTree = ""; + }; + 33CC10E42044A3C60003C045 = { + isa = PBXGroup; + children = ( + 33FAB671232836740065AC1E /* Runner */, + 33CEB47122A05771004F2AC0 /* Flutter */, + 331C80D6294CF71000263BE5 /* RunnerTests */, + 33CC10EE2044A3C60003C045 /* Products */, + D73912EC22F37F3D000D13A0 /* Frameworks */, + 273427FD9215EDCCEE698DEE /* Pods */, + ); + sourceTree = ""; + }; + 33CC10EE2044A3C60003C045 /* Products */ = { + isa = PBXGroup; + children = ( + 33CC10ED2044A3C60003C045 /* native_auth_flutter_example.app */, + 331C80D5294CF71000263BE5 /* RunnerTests.xctest */, + ); + name = Products; + sourceTree = ""; + }; + 33CC11242044D66E0003C045 /* Resources */ = { + isa = PBXGroup; + children = ( + 33CC10F22044A3C60003C045 /* Assets.xcassets */, + 33CC10F42044A3C60003C045 /* MainMenu.xib */, + 33CC10F72044A3C60003C045 /* Info.plist */, + ); + name = Resources; + path = ..; + sourceTree = ""; + }; + 33CEB47122A05771004F2AC0 /* Flutter */ = { + isa = PBXGroup; + children = ( + 335BBD1A22A9A15E00E9071D /* GeneratedPluginRegistrant.swift */, + 33CEB47222A05771004F2AC0 /* Flutter-Debug.xcconfig */, + 33CEB47422A05771004F2AC0 /* Flutter-Release.xcconfig */, + 33CEB47722A0578A004F2AC0 /* Flutter-Generated.xcconfig */, + ); + path = Flutter; + sourceTree = ""; + }; + 33FAB671232836740065AC1E /* Runner */ = { + isa = PBXGroup; + children = ( + 33CC10F02044A3C60003C045 /* AppDelegate.swift */, + 33CC11122044BFA00003C045 /* MainFlutterWindow.swift */, + 33E51913231747F40026EE4D /* DebugProfile.entitlements */, + 33E51914231749380026EE4D /* Release.entitlements */, + 33CC11242044D66E0003C045 /* Resources */, + 33BA886A226E78AF003329D5 /* Configs */, + ); + path = Runner; + sourceTree = ""; + }; + D73912EC22F37F3D000D13A0 /* Frameworks */ = { + isa = PBXGroup; + children = ( + 15AA952EC1A4DDEC3A777BD3 /* Pods_Runner.framework */, + 0F2ED5785FC9F9FAE6F2EA75 /* Pods_RunnerTests.framework */, + ); + name = Frameworks; + sourceTree = ""; + }; +/* End PBXGroup section */ + +/* Begin PBXNativeTarget section */ + 331C80D4294CF70F00263BE5 /* RunnerTests */ = { + isa = PBXNativeTarget; + buildConfigurationList = 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */; + buildPhases = ( + 8BB46D91D906A314AE401706 /* [CP] Check Pods Manifest.lock */, + 331C80D1294CF70F00263BE5 /* Sources */, + 331C80D2294CF70F00263BE5 /* Frameworks */, + 331C80D3294CF70F00263BE5 /* Resources */, + ); + buildRules = ( + ); + dependencies = ( + 331C80DA294CF71000263BE5 /* PBXTargetDependency */, + ); + name = RunnerTests; + productName = RunnerTests; + productReference = 331C80D5294CF71000263BE5 /* RunnerTests.xctest */; + productType = "com.apple.product-type.bundle.unit-test"; + }; + 33CC10EC2044A3C60003C045 /* Runner */ = { + isa = PBXNativeTarget; + buildConfigurationList = 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */; + buildPhases = ( + 09F5F0C73F17586B929FDF07 /* [CP] Check Pods Manifest.lock */, + 33CC10E92044A3C60003C045 /* Sources */, + 33CC10EA2044A3C60003C045 /* Frameworks */, + 33CC10EB2044A3C60003C045 /* Resources */, + 33CC110E2044A8840003C045 /* Bundle Framework */, + 3399D490228B24CF009A79C7 /* ShellScript */, + 34827092D314E7D01C873172 /* [CP] Embed Pods Frameworks */, + ); + buildRules = ( + ); + dependencies = ( + 33CC11202044C79F0003C045 /* PBXTargetDependency */, + ); + name = Runner; + productName = Runner; + productReference = 33CC10ED2044A3C60003C045 /* native_auth_flutter_example.app */; + productType = "com.apple.product-type.application"; + }; +/* End PBXNativeTarget section */ + +/* Begin PBXProject section */ + 33CC10E52044A3C60003C045 /* Project object */ = { + isa = PBXProject; + attributes = { + BuildIndependentTargetsInParallel = YES; + LastSwiftUpdateCheck = 0920; + LastUpgradeCheck = 1510; + ORGANIZATIONNAME = ""; + TargetAttributes = { + 331C80D4294CF70F00263BE5 = { + CreatedOnToolsVersion = 14.0; + TestTargetID = 33CC10EC2044A3C60003C045; + }; + 33CC10EC2044A3C60003C045 = { + CreatedOnToolsVersion = 9.2; + LastSwiftMigration = 1100; + ProvisioningStyle = Automatic; + SystemCapabilities = { + com.apple.Sandbox = { + enabled = 1; + }; + }; + }; + 33CC111A2044C6BA0003C045 = { + CreatedOnToolsVersion = 9.2; + ProvisioningStyle = Manual; + }; + }; + }; + buildConfigurationList = 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */; + compatibilityVersion = "Xcode 9.3"; + developmentRegion = en; + hasScannedForEncodings = 0; + knownRegions = ( + en, + Base, + ); + mainGroup = 33CC10E42044A3C60003C045; + productRefGroup = 33CC10EE2044A3C60003C045 /* Products */; + projectDirPath = ""; + projectRoot = ""; + targets = ( + 33CC10EC2044A3C60003C045 /* Runner */, + 331C80D4294CF70F00263BE5 /* RunnerTests */, + 33CC111A2044C6BA0003C045 /* Flutter Assemble */, + ); + }; +/* End PBXProject section */ + +/* Begin PBXResourcesBuildPhase section */ + 331C80D3294CF70F00263BE5 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10EB2044A3C60003C045 /* Resources */ = { + isa = PBXResourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC10F32044A3C60003C045 /* Assets.xcassets in Resources */, + 33CC10F62044A3C60003C045 /* MainMenu.xib in Resources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXResourcesBuildPhase section */ + +/* Begin PBXShellScriptBuildPhase section */ + 09F5F0C73F17586B929FDF07 /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-Runner-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; + 3399D490228B24CF009A79C7 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + alwaysOutOfDate = 1; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + ); + outputFileListPaths = ( + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "echo \"$PRODUCT_NAME.app\" > \"$PROJECT_DIR\"/Flutter/ephemeral/.app_filename && \"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh embed\n"; + }; + 33CC111E2044C6BF0003C045 /* ShellScript */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + Flutter/ephemeral/FlutterInputs.xcfilelist, + ); + inputPaths = ( + Flutter/ephemeral/tripwire, + ); + outputFileListPaths = ( + Flutter/ephemeral/FlutterOutputs.xcfilelist, + ); + outputPaths = ( + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"$FLUTTER_ROOT\"/packages/flutter_tools/bin/macos_assemble.sh && touch Flutter/ephemeral/tripwire"; + }; + 34827092D314E7D01C873172 /* [CP] Embed Pods Frameworks */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-input-files.xcfilelist", + ); + name = "[CP] Embed Pods Frameworks"; + outputFileListPaths = ( + "${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks-${CONFIGURATION}-output-files.xcfilelist", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "\"${PODS_ROOT}/Target Support Files/Pods-Runner/Pods-Runner-frameworks.sh\"\n"; + showEnvVarsInLog = 0; + }; + 8BB46D91D906A314AE401706 /* [CP] Check Pods Manifest.lock */ = { + isa = PBXShellScriptBuildPhase; + buildActionMask = 2147483647; + files = ( + ); + inputFileListPaths = ( + ); + inputPaths = ( + "${PODS_PODFILE_DIR_PATH}/Podfile.lock", + "${PODS_ROOT}/Manifest.lock", + ); + name = "[CP] Check Pods Manifest.lock"; + outputFileListPaths = ( + ); + outputPaths = ( + "$(DERIVED_FILE_DIR)/Pods-RunnerTests-checkManifestLockResult.txt", + ); + runOnlyForDeploymentPostprocessing = 0; + shellPath = /bin/sh; + shellScript = "diff \"${PODS_PODFILE_DIR_PATH}/Podfile.lock\" \"${PODS_ROOT}/Manifest.lock\" > /dev/null\nif [ $? != 0 ] ; then\n # print error to STDERR\n echo \"error: The sandbox is not in sync with the Podfile.lock. Run 'pod install' or update your CocoaPods installation.\" >&2\n exit 1\nfi\n# This output is used by Xcode 'outputs' to avoid re-running this script phase.\necho \"SUCCESS\" > \"${SCRIPT_OUTPUT_FILE_0}\"\n"; + showEnvVarsInLog = 0; + }; +/* End PBXShellScriptBuildPhase section */ + +/* Begin PBXSourcesBuildPhase section */ + 331C80D1294CF70F00263BE5 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 331C80D8294CF71000263BE5 /* RunnerTests.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; + 33CC10E92044A3C60003C045 /* Sources */ = { + isa = PBXSourcesBuildPhase; + buildActionMask = 2147483647; + files = ( + 33CC11132044BFA00003C045 /* MainFlutterWindow.swift in Sources */, + 33CC10F12044A3C60003C045 /* AppDelegate.swift in Sources */, + 335BBD1B22A9A15E00E9071D /* GeneratedPluginRegistrant.swift in Sources */, + ); + runOnlyForDeploymentPostprocessing = 0; + }; +/* End PBXSourcesBuildPhase section */ + +/* Begin PBXTargetDependency section */ + 331C80DA294CF71000263BE5 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC10EC2044A3C60003C045 /* Runner */; + targetProxy = 331C80D9294CF71000263BE5 /* PBXContainerItemProxy */; + }; + 33CC11202044C79F0003C045 /* PBXTargetDependency */ = { + isa = PBXTargetDependency; + target = 33CC111A2044C6BA0003C045 /* Flutter Assemble */; + targetProxy = 33CC111F2044C79F0003C045 /* PBXContainerItemProxy */; + }; +/* End PBXTargetDependency section */ + +/* Begin PBXVariantGroup section */ + 33CC10F42044A3C60003C045 /* MainMenu.xib */ = { + isa = PBXVariantGroup; + children = ( + 33CC10F52044A3C60003C045 /* Base */, + ); + name = MainMenu.xib; + path = Runner; + sourceTree = ""; + }; +/* End PBXVariantGroup section */ + +/* Begin XCBuildConfiguration section */ + 331C80DB294CF71000263BE5 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7E92109DC1C25CBF7CEEAE7B /* Pods-RunnerTests.debug.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/native_auth_flutter_example.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/native_auth_flutter_example"; + }; + name = Debug; + }; + 331C80DC294CF71000263BE5 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 83EA378EFDF03C51D2D094F3 /* Pods-RunnerTests.release.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/native_auth_flutter_example.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/native_auth_flutter_example"; + }; + name = Release; + }; + 331C80DD294CF71000263BE5 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = E9AC8262B7AEAFCE85179156 /* Pods-RunnerTests.profile.xcconfig */; + buildSettings = { + BUNDLE_LOADER = "$(TEST_HOST)"; + CURRENT_PROJECT_VERSION = 1; + GENERATE_INFOPLIST_FILE = YES; + MARKETING_VERSION = 1.0; + PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample.RunnerTests; + PRODUCT_NAME = "$(TARGET_NAME)"; + SWIFT_VERSION = 5.0; + TEST_HOST = "$(BUILT_PRODUCTS_DIR)/native_auth_flutter_example.app/$(BUNDLE_EXECUTABLE_FOLDER_PATH)/native_auth_flutter_example"; + }; + name = Profile; + }; + 338D0CE9231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.15; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Profile; + }; + 338D0CEA231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + "CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = 3N44X5LWWW; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + MACOSX_DEPLOYMENT_TARGET = 10.15; + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Profile; + }; + 338D0CEB231458BD00FA5F75 /* Profile */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Profile; + }; + 33CC10F92044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 9740EEB21CF90195004384FC /* Debug.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = dwarf; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_TESTABILITY = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_DYNAMIC_NO_PIC = NO; + GCC_NO_COMMON_BLOCKS = YES; + GCC_OPTIMIZATION_LEVEL = 0; + GCC_PREPROCESSOR_DEFINITIONS = ( + "DEBUG=1", + "$(inherited)", + ); + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.15; + MTL_ENABLE_DEBUG_INFO = YES; + ONLY_ACTIVE_ARCH = YES; + SDKROOT = macosx; + SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + }; + name = Debug; + }; + 33CC10FA2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 7AFA3C8E1D35360C0083082E /* Release.xcconfig */; + buildSettings = { + ALWAYS_SEARCH_USER_PATHS = NO; + ASSETCATALOG_COMPILER_GENERATE_SWIFT_ASSET_SYMBOL_EXTENSIONS = YES; + CLANG_ANALYZER_NONNULL = YES; + CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; + CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; + CLANG_CXX_LIBRARY = "libc++"; + CLANG_ENABLE_MODULES = YES; + CLANG_ENABLE_OBJC_ARC = YES; + CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; + CLANG_WARN_BOOL_CONVERSION = YES; + CLANG_WARN_CONSTANT_CONVERSION = YES; + CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; + CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; + CLANG_WARN_DOCUMENTATION_COMMENTS = YES; + CLANG_WARN_EMPTY_BODY = YES; + CLANG_WARN_ENUM_CONVERSION = YES; + CLANG_WARN_INFINITE_RECURSION = YES; + CLANG_WARN_INT_CONVERSION = YES; + CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; + CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; + CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; + CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; + CLANG_WARN_SUSPICIOUS_MOVE = YES; + CODE_SIGN_IDENTITY = "-"; + COPY_PHASE_STRIP = NO; + DEAD_CODE_STRIPPING = YES; + DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; + ENABLE_NS_ASSERTIONS = NO; + ENABLE_STRICT_OBJC_MSGSEND = YES; + ENABLE_USER_SCRIPT_SANDBOXING = NO; + GCC_C_LANGUAGE_STANDARD = gnu11; + GCC_NO_COMMON_BLOCKS = YES; + GCC_WARN_64_TO_32_BIT_CONVERSION = YES; + GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; + GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; + GCC_WARN_UNUSED_FUNCTION = YES; + GCC_WARN_UNUSED_VARIABLE = YES; + MACOSX_DEPLOYMENT_TARGET = 10.15; + MTL_ENABLE_DEBUG_INFO = NO; + SDKROOT = macosx; + SWIFT_COMPILATION_MODE = wholemodule; + SWIFT_OPTIMIZATION_LEVEL = "-O"; + }; + name = Release; + }; + 33CC10FC2044A3C60003C045 /* Debug */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/DebugProfile.entitlements; + "CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = 3N44X5LWWW; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + MACOSX_DEPLOYMENT_TARGET = 10.15; + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_OPTIMIZATION_LEVEL = "-Onone"; + SWIFT_VERSION = 5.0; + }; + name = Debug; + }; + 33CC10FD2044A3C60003C045 /* Release */ = { + isa = XCBuildConfiguration; + baseConfigurationReference = 33E5194F232828860026EE4D /* AppInfo.xcconfig */; + buildSettings = { + ASSETCATALOG_COMPILER_APPICON_NAME = AppIcon; + CLANG_ENABLE_MODULES = YES; + CODE_SIGN_ENTITLEMENTS = Runner/Release.entitlements; + "CODE_SIGN_IDENTITY[sdk=macosx*]" = "Apple Development"; + CODE_SIGN_STYLE = Automatic; + COMBINE_HIDPI_IMAGES = YES; + DEVELOPMENT_TEAM = 3N44X5LWWW; + INFOPLIST_FILE = Runner/Info.plist; + LD_RUNPATH_SEARCH_PATHS = ( + "$(inherited)", + "@executable_path/../Frameworks", + ); + MACOSX_DEPLOYMENT_TARGET = 10.15; + PROVISIONING_PROFILE_SPECIFIER = ""; + SWIFT_VERSION = 5.0; + }; + name = Release; + }; + 33CC111C2044C6BA0003C045 /* Debug */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Manual; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Debug; + }; + 33CC111D2044C6BA0003C045 /* Release */ = { + isa = XCBuildConfiguration; + buildSettings = { + CODE_SIGN_STYLE = Automatic; + PRODUCT_NAME = "$(TARGET_NAME)"; + }; + name = Release; + }; +/* End XCBuildConfiguration section */ + +/* Begin XCConfigurationList section */ + 331C80DE294CF71000263BE5 /* Build configuration list for PBXNativeTarget "RunnerTests" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 331C80DB294CF71000263BE5 /* Debug */, + 331C80DC294CF71000263BE5 /* Release */, + 331C80DD294CF71000263BE5 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10E82044A3C60003C045 /* Build configuration list for PBXProject "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10F92044A3C60003C045 /* Debug */, + 33CC10FA2044A3C60003C045 /* Release */, + 338D0CE9231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC10FB2044A3C60003C045 /* Build configuration list for PBXNativeTarget "Runner" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC10FC2044A3C60003C045 /* Debug */, + 33CC10FD2044A3C60003C045 /* Release */, + 338D0CEA231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; + 33CC111B2044C6BA0003C045 /* Build configuration list for PBXAggregateTarget "Flutter Assemble" */ = { + isa = XCConfigurationList; + buildConfigurations = ( + 33CC111C2044C6BA0003C045 /* Debug */, + 33CC111D2044C6BA0003C045 /* Release */, + 338D0CEB231458BD00FA5F75 /* Profile */, + ); + defaultConfigurationIsVisible = 0; + defaultConfigurationName = Release; + }; +/* End XCConfigurationList section */ + }; + rootObject = 33CC10E52044A3C60003C045 /* Project object */; +} diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme new file mode 100644 index 0000000..4f5dbb9 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcodeproj/xcshareddata/xcschemes/Runner.xcscheme @@ -0,0 +1,98 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner.xcworkspace/contents.xcworkspacedata b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcworkspace/contents.xcworkspacedata new file mode 100644 index 0000000..21a3cc1 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcworkspace/contents.xcworkspacedata @@ -0,0 +1,10 @@ + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist new file mode 100644 index 0000000..18d9810 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist @@ -0,0 +1,8 @@ + + + + + IDEDidComputeMac32BitWarning + + + diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/AppDelegate.swift b/packages/native/auth/native_auth_flutter/example/macos/Runner/AppDelegate.swift new file mode 100644 index 0000000..8e02df2 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/AppDelegate.swift @@ -0,0 +1,9 @@ +import Cocoa +import FlutterMacOS + +@main +class AppDelegate: FlutterAppDelegate { + override func applicationShouldTerminateAfterLastWindowClosed(_ sender: NSApplication) -> Bool { + return true + } +} diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json new file mode 100644 index 0000000..a2ec33f --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/Contents.json @@ -0,0 +1,68 @@ +{ + "images" : [ + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_16.png", + "scale" : "1x" + }, + { + "size" : "16x16", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "2x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_32.png", + "scale" : "1x" + }, + { + "size" : "32x32", + "idiom" : "mac", + "filename" : "app_icon_64.png", + "scale" : "2x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_128.png", + "scale" : "1x" + }, + { + "size" : "128x128", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "2x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_256.png", + "scale" : "1x" + }, + { + "size" : "256x256", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "2x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_512.png", + "scale" : "1x" + }, + { + "size" : "512x512", + "idiom" : "mac", + "filename" : "app_icon_1024.png", + "scale" : "2x" + } + ], + "info" : { + "version" : 1, + "author" : "xcode" + } +} diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png new file mode 100644 index 0000000..82b6f9d Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png differ diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png new file mode 100644 index 0000000..13b35eb Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_128.png differ diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png new file mode 100644 index 0000000..0a3f5fa Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_16.png differ diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png new file mode 100644 index 0000000..bdb5722 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_256.png differ diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png new file mode 100644 index 0000000..f083318 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_32.png differ diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png new file mode 100644 index 0000000..326c0e7 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_512.png differ diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png new file mode 100644 index 0000000..2f1632c Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_64.png differ diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Base.lproj/MainMenu.xib b/packages/native/auth/native_auth_flutter/example/macos/Runner/Base.lproj/MainMenu.xib new file mode 100644 index 0000000..80e867a --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/Base.lproj/MainMenu.xib @@ -0,0 +1,343 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/AppInfo.xcconfig b/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/AppInfo.xcconfig new file mode 100644 index 0000000..df1fd7f --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/AppInfo.xcconfig @@ -0,0 +1,14 @@ +// Application-level settings for the Runner target. +// +// This may be replaced with something auto-generated from metadata (e.g., pubspec.yaml) in the +// future. If not, the values below would default to using the project name when this becomes a +// 'flutter create' template. + +// The application's name. By default this is also the title of the Flutter window. +PRODUCT_NAME = native_auth_flutter_example + +// The application's bundle identifier +PRODUCT_BUNDLE_IDENTIFIER = dev.celest.nativeAuthFlutterExample + +// The copyright displayed in application information +PRODUCT_COPYRIGHT = Copyright © 2024 dev.celest. All rights reserved. diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/Debug.xcconfig b/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/Debug.xcconfig new file mode 100644 index 0000000..36b0fd9 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/Debug.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Debug.xcconfig" +#include "Warnings.xcconfig" diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/Release.xcconfig b/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/Release.xcconfig new file mode 100644 index 0000000..dff4f49 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/Release.xcconfig @@ -0,0 +1,2 @@ +#include "../../Flutter/Flutter-Release.xcconfig" +#include "Warnings.xcconfig" diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/Warnings.xcconfig b/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/Warnings.xcconfig new file mode 100644 index 0000000..42bcbf4 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/Configs/Warnings.xcconfig @@ -0,0 +1,13 @@ +WARNING_CFLAGS = -Wall -Wconditional-uninitialized -Wnullable-to-nonnull-conversion -Wmissing-method-return-type -Woverlength-strings +GCC_WARN_UNDECLARED_SELECTOR = YES +CLANG_UNDEFINED_BEHAVIOR_SANITIZER_NULLABILITY = YES +CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE +CLANG_WARN__DUPLICATE_METHOD_MATCH = YES +CLANG_WARN_PRAGMA_PACK = YES +CLANG_WARN_STRICT_PROTOTYPES = YES +CLANG_WARN_COMMA = YES +GCC_WARN_STRICT_SELECTOR_MATCH = YES +CLANG_WARN_OBJC_REPEATED_USE_OF_WEAK = YES +CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES +GCC_WARN_SHADOW = YES +CLANG_WARN_UNREACHABLE_CODE = YES diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/DebugProfile.entitlements b/packages/native/auth/native_auth_flutter/example/macos/Runner/DebugProfile.entitlements new file mode 100644 index 0000000..3ba6c12 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/DebugProfile.entitlements @@ -0,0 +1,14 @@ + + + + + com.apple.security.app-sandbox + + com.apple.security.cs.allow-jit + + com.apple.security.network.client + + com.apple.security.network.server + + + diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Info.plist b/packages/native/auth/native_auth_flutter/example/macos/Runner/Info.plist new file mode 100644 index 0000000..4789daa --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/Info.plist @@ -0,0 +1,32 @@ + + + + + CFBundleDevelopmentRegion + $(DEVELOPMENT_LANGUAGE) + CFBundleExecutable + $(EXECUTABLE_NAME) + CFBundleIconFile + + CFBundleIdentifier + $(PRODUCT_BUNDLE_IDENTIFIER) + CFBundleInfoDictionaryVersion + 6.0 + CFBundleName + $(PRODUCT_NAME) + CFBundlePackageType + APPL + CFBundleShortVersionString + $(FLUTTER_BUILD_NAME) + CFBundleVersion + $(FLUTTER_BUILD_NUMBER) + LSMinimumSystemVersion + $(MACOSX_DEPLOYMENT_TARGET) + NSHumanReadableCopyright + $(PRODUCT_COPYRIGHT) + NSMainNibFile + MainMenu + NSPrincipalClass + NSApplication + + diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/MainFlutterWindow.swift b/packages/native/auth/native_auth_flutter/example/macos/Runner/MainFlutterWindow.swift new file mode 100644 index 0000000..3cc05eb --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/MainFlutterWindow.swift @@ -0,0 +1,15 @@ +import Cocoa +import FlutterMacOS + +class MainFlutterWindow: NSWindow { + override func awakeFromNib() { + let flutterViewController = FlutterViewController() + let windowFrame = self.frame + self.contentViewController = flutterViewController + self.setFrame(windowFrame, display: true) + + RegisterGeneratedPlugins(registry: flutterViewController) + + super.awakeFromNib() + } +} diff --git a/packages/native/auth/native_auth_flutter/example/macos/Runner/Release.entitlements b/packages/native/auth/native_auth_flutter/example/macos/Runner/Release.entitlements new file mode 100644 index 0000000..7a2230d --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/Runner/Release.entitlements @@ -0,0 +1,12 @@ + + + + + com.apple.security.app-sandbox + + com.apple.security.network.client + + com.apple.security.network.server + + + diff --git a/packages/native/auth/native_auth_flutter/example/macos/RunnerTests/RunnerTests.swift b/packages/native/auth/native_auth_flutter/example/macos/RunnerTests/RunnerTests.swift new file mode 100644 index 0000000..61f3bd1 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/macos/RunnerTests/RunnerTests.swift @@ -0,0 +1,12 @@ +import Cocoa +import FlutterMacOS +import XCTest + +class RunnerTests: XCTestCase { + + func testExample() { + // If you add code to the Runner application, consider adding tests here. + // See https://developer.apple.com/documentation/xctest for more information about using XCTest. + } + +} diff --git a/packages/native/auth/native_auth_flutter/example/pubspec.lock b/packages/native/auth/native_auth_flutter/example/pubspec.lock new file mode 100644 index 0000000..b419507 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/pubspec.lock @@ -0,0 +1,292 @@ +# Generated by pub +# See https://dart.dev/tools/pub/glossary#lockfile +packages: + args: + dependency: transitive + description: + name: args + sha256: "7cf60b9f0cc88203c5a190b4cd62a99feea42759a7fa695010eb5de1c0b2252a" + url: "https://pub.dev" + source: hosted + version: "2.5.0" + async: + dependency: transitive + description: + name: async + sha256: "947bfcf187f74dbc5e146c9eb9c0f10c9f8b30743e341481c1e2ed3ecc18c20c" + url: "https://pub.dev" + source: hosted + version: "2.11.0" + boolean_selector: + dependency: transitive + description: + name: boolean_selector + sha256: "6cfb5af12253eaf2b368f07bacc5a80d1301a071c73360d746b7f2e32d762c66" + url: "https://pub.dev" + source: hosted + version: "2.1.1" + characters: + dependency: transitive + description: + name: characters + sha256: "04a925763edad70e8443c99234dc3328f442e811f1d8fd1a72f1c8ad0f69a605" + url: "https://pub.dev" + source: hosted + version: "1.3.0" + clock: + dependency: transitive + description: + name: clock + sha256: cb6d7f03e1de671e34607e909a7213e31d7752be4fb66a86d29fe1eb14bfb5cf + url: "https://pub.dev" + source: hosted + version: "1.1.1" + collection: + dependency: transitive + description: + name: collection + sha256: ee67cb0715911d28db6bf4af1026078bd6f0128b07a5f66fb2ed94ec6783c09a + url: "https://pub.dev" + source: hosted + version: "1.18.0" + fake_async: + dependency: transitive + description: + name: fake_async + sha256: "511392330127add0b769b75a987850d136345d9227c6b94c96a04cf4a391bf78" + url: "https://pub.dev" + source: hosted + version: "1.3.1" + ffi: + dependency: transitive + description: + name: ffi + sha256: "16ed7b077ef01ad6170a3d0c57caa4a112a38d7a2ed5602e0aca9ca6f3d98da6" + url: "https://pub.dev" + source: hosted + version: "2.1.3" + flutter: + dependency: "direct main" + description: flutter + source: sdk + version: "0.0.0" + flutter_lints: + dependency: "direct dev" + description: + name: flutter_lints + sha256: "3f41d009ba7172d5ff9be5f6e6e6abb4300e263aab8866d2a0842ed2a70f8f0c" + url: "https://pub.dev" + source: hosted + version: "4.0.0" + flutter_test: + dependency: "direct dev" + description: flutter + source: sdk + version: "0.0.0" + jni: + dependency: transitive + description: + name: jni + sha256: "85cf3fbc8ce837e09b4cfe59d688c0249a5b9f4cc9a9a5be38e2823f218988a8" + url: "https://pub.dev" + source: hosted + version: "0.9.3" + leak_tracker: + dependency: transitive + description: + name: leak_tracker + sha256: "3f87a60e8c63aecc975dda1ceedbc8f24de75f09e4856ea27daf8958f2f0ce05" + url: "https://pub.dev" + source: hosted + version: "10.0.5" + leak_tracker_flutter_testing: + dependency: transitive + description: + name: leak_tracker_flutter_testing + sha256: "932549fb305594d82d7183ecd9fa93463e9914e1b67cacc34bc40906594a1806" + url: "https://pub.dev" + source: hosted + version: "3.0.5" + leak_tracker_testing: + dependency: transitive + description: + name: leak_tracker_testing + sha256: "6ba465d5d76e67ddf503e1161d1f4a6bc42306f9d66ca1e8f079a47290fb06d3" + url: "https://pub.dev" + source: hosted + version: "3.0.1" + lints: + dependency: transitive + description: + name: lints + sha256: "976c774dd944a42e83e2467f4cc670daef7eed6295b10b36ae8c85bcbf828235" + url: "https://pub.dev" + source: hosted + version: "4.0.0" + logging: + dependency: "direct main" + description: + name: logging + sha256: "623a88c9594aa774443aa3eb2d41807a48486b5613e67599fb4c41c0ad47c340" + url: "https://pub.dev" + source: hosted + version: "1.2.0" + matcher: + dependency: transitive + description: + name: matcher + sha256: d2323aa2060500f906aa31a895b4030b6da3ebdcc5619d14ce1aada65cd161cb + url: "https://pub.dev" + source: hosted + version: "0.12.16+1" + material_color_utilities: + dependency: transitive + description: + name: material_color_utilities + sha256: f7142bb1154231d7ea5f96bc7bde4bda2a0945d2806bb11670e30b850d56bdec + url: "https://pub.dev" + source: hosted + version: "0.11.1" + meta: + dependency: transitive + description: + name: meta + sha256: bdb68674043280c3428e9ec998512fb681678676b3c54e773629ffe74419f8c7 + url: "https://pub.dev" + source: hosted + version: "1.15.0" + native_auth_flutter: + dependency: "direct main" + description: + path: ".." + relative: true + source: path + version: "0.1.0" + objective_c: + dependency: transitive + description: + name: objective_c + sha256: "77c341fce45bb3865a7bc3ddee4201605799e3de2f7af200e8dae26369d210ea" + url: "https://pub.dev" + source: hosted + version: "1.1.0" + package_config: + dependency: transitive + description: + name: package_config + sha256: "1c5b77ccc91e4823a5af61ee74e6b972db1ef98c2ff5a18d3161c982a55448bd" + url: "https://pub.dev" + source: hosted + version: "2.1.0" + path: + dependency: transitive + description: + name: path + sha256: "087ce49c3f0dc39180befefc60fdb4acd8f8620e5682fe2476afd0b3688bb4af" + url: "https://pub.dev" + source: hosted + version: "1.9.0" + plugin_platform_interface: + dependency: transitive + description: + name: plugin_platform_interface + sha256: "4820fbfdb9478b1ebae27888254d445073732dae3d6ea81f0b7e06d5dedc3f02" + url: "https://pub.dev" + source: hosted + version: "2.1.8" + sky_engine: + dependency: transitive + description: flutter + source: sdk + version: "0.0.99" + source_span: + dependency: transitive + description: + name: source_span + sha256: "53e943d4206a5e30df338fd4c6e7a077e02254531b138a15aec3bd143c1a8b3c" + url: "https://pub.dev" + source: hosted + version: "1.10.0" + stack_trace: + dependency: transitive + description: + name: stack_trace + sha256: "73713990125a6d93122541237550ee3352a2d84baad52d375a4cad2eb9b7ce0b" + url: "https://pub.dev" + source: hosted + version: "1.11.1" + stream_channel: + dependency: transitive + description: + name: stream_channel + sha256: ba2aa5d8cc609d96bbb2899c28934f9e1af5cddbd60a827822ea467161eb54e7 + url: "https://pub.dev" + source: hosted + version: "2.1.2" + stream_transform: + dependency: transitive + description: + name: stream_transform + sha256: "14a00e794c7c11aa145a170587321aedce29769c08d7f58b1d141da75e3b1c6f" + url: "https://pub.dev" + source: hosted + version: "2.1.0" + string_scanner: + dependency: transitive + description: + name: string_scanner + sha256: "556692adab6cfa87322a115640c11f13cb77b3f076ddcc5d6ae3c20242bedcde" + url: "https://pub.dev" + source: hosted + version: "1.2.0" + term_glyph: + dependency: transitive + description: + name: term_glyph + sha256: a29248a84fbb7c79282b40b8c72a1209db169a2e0542bce341da992fe1bc7e84 + url: "https://pub.dev" + source: hosted + version: "1.2.1" + test_api: + dependency: transitive + description: + name: test_api + sha256: "5b8a98dafc4d5c4c9c72d8b31ab2b23fc13422348d2997120294d3bac86b4ddb" + url: "https://pub.dev" + source: hosted + version: "0.7.2" + vector_math: + dependency: transitive + description: + name: vector_math + sha256: "80b3257d1492ce4d091729e3a67a60407d227c27241d6927be0130c98e741803" + url: "https://pub.dev" + source: hosted + version: "2.1.4" + vm_service: + dependency: transitive + description: + name: vm_service + sha256: f652077d0bdf60abe4c1f6377448e8655008eef28f128bc023f7b5e8dfeb48fc + url: "https://pub.dev" + source: hosted + version: "14.2.4" + web: + dependency: "direct overridden" + description: + name: web + sha256: d43c1d6b787bf0afad444700ae7f4db8827f701bc61c255ac8d328c6f4d52062 + url: "https://pub.dev" + source: hosted + version: "1.0.0" + yaml: + dependency: transitive + description: + name: yaml + sha256: "75769501ea3489fca56601ff33454fe45507ea3bfb014161abc3b43ae25989d5" + url: "https://pub.dev" + source: hosted + version: "3.1.2" +sdks: + dart: ">=3.3.0 <4.0.0" + flutter: ">=3.19.0" diff --git a/packages/native/auth/native_auth_flutter/example/pubspec.yaml b/packages/native/auth/native_auth_flutter/example/pubspec.yaml new file mode 100644 index 0000000..033581d --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/pubspec.yaml @@ -0,0 +1,24 @@ +name: native_auth_flutter_example +description: "Demonstrates how to use the native_auth_flutter plugin." +publish_to: 'none' + +environment: + sdk: ^3.3.0 + +dependencies: + flutter: + sdk: flutter + logging: ^1.2.0 + native_auth_flutter: + path: ../ + +dependency_overrides: + web: ^1.0.0 + +dev_dependencies: + flutter_test: + sdk: flutter + flutter_lints: ^4.0.0 + +flutter: + uses-material-design: true diff --git a/packages/native/auth/native_auth_flutter/example/web/favicon.png b/packages/native/auth/native_auth_flutter/example/web/favicon.png new file mode 100644 index 0000000..8aaa46a Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/web/favicon.png differ diff --git a/packages/native/auth/native_auth_flutter/example/web/icons/Icon-192.png b/packages/native/auth/native_auth_flutter/example/web/icons/Icon-192.png new file mode 100644 index 0000000..b749bfe Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/web/icons/Icon-192.png differ diff --git a/packages/native/auth/native_auth_flutter/example/web/icons/Icon-512.png b/packages/native/auth/native_auth_flutter/example/web/icons/Icon-512.png new file mode 100644 index 0000000..88cfd48 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/web/icons/Icon-512.png differ diff --git a/packages/native/auth/native_auth_flutter/example/web/icons/Icon-maskable-192.png b/packages/native/auth/native_auth_flutter/example/web/icons/Icon-maskable-192.png new file mode 100644 index 0000000..eb9b4d7 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/web/icons/Icon-maskable-192.png differ diff --git a/packages/native/auth/native_auth_flutter/example/web/icons/Icon-maskable-512.png b/packages/native/auth/native_auth_flutter/example/web/icons/Icon-maskable-512.png new file mode 100644 index 0000000..d69c566 Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/web/icons/Icon-maskable-512.png differ diff --git a/packages/native/auth/native_auth_flutter/example/web/index.html b/packages/native/auth/native_auth_flutter/example/web/index.html new file mode 100644 index 0000000..1aa025d --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/web/index.html @@ -0,0 +1,38 @@ + + + + + + + + + + + + + + + + + + + + example + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/web/manifest.json b/packages/native/auth/native_auth_flutter/example/web/manifest.json new file mode 100644 index 0000000..096edf8 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/web/manifest.json @@ -0,0 +1,35 @@ +{ + "name": "example", + "short_name": "example", + "start_url": ".", + "display": "standalone", + "background_color": "#0175C2", + "theme_color": "#0175C2", + "description": "A new Flutter project.", + "orientation": "portrait-primary", + "prefer_related_applications": false, + "icons": [ + { + "src": "icons/Icon-192.png", + "sizes": "192x192", + "type": "image/png" + }, + { + "src": "icons/Icon-512.png", + "sizes": "512x512", + "type": "image/png" + }, + { + "src": "icons/Icon-maskable-192.png", + "sizes": "192x192", + "type": "image/png", + "purpose": "maskable" + }, + { + "src": "icons/Icon-maskable-512.png", + "sizes": "512x512", + "type": "image/png", + "purpose": "maskable" + } + ] +} diff --git a/packages/native/auth/native_auth_flutter/example/windows/.gitignore b/packages/native/auth/native_auth_flutter/example/windows/.gitignore new file mode 100644 index 0000000..d492d0d --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/.gitignore @@ -0,0 +1,17 @@ +flutter/ephemeral/ + +# Visual Studio user-specific files. +*.suo +*.user +*.userosscache +*.sln.docstates + +# Visual Studio build-related files. +x64/ +x86/ + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!*.[Cc]ache/ diff --git a/packages/native/auth/native_auth_flutter/example/windows/CMakeLists.txt b/packages/native/auth/native_auth_flutter/example/windows/CMakeLists.txt new file mode 100644 index 0000000..d960948 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/CMakeLists.txt @@ -0,0 +1,108 @@ +# Project-level configuration. +cmake_minimum_required(VERSION 3.14) +project(example LANGUAGES CXX) + +# The name of the executable created for the application. Change this to change +# the on-disk name of your application. +set(BINARY_NAME "example") + +# Explicitly opt in to modern CMake behaviors to avoid warnings with recent +# versions of CMake. +cmake_policy(VERSION 3.14...3.25) + +# Define build configuration option. +get_property(IS_MULTICONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG) +if(IS_MULTICONFIG) + set(CMAKE_CONFIGURATION_TYPES "Debug;Profile;Release" + CACHE STRING "" FORCE) +else() + if(NOT CMAKE_BUILD_TYPE AND NOT CMAKE_CONFIGURATION_TYPES) + set(CMAKE_BUILD_TYPE "Debug" CACHE + STRING "Flutter build mode" FORCE) + set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS + "Debug" "Profile" "Release") + endif() +endif() +# Define settings for the Profile build mode. +set(CMAKE_EXE_LINKER_FLAGS_PROFILE "${CMAKE_EXE_LINKER_FLAGS_RELEASE}") +set(CMAKE_SHARED_LINKER_FLAGS_PROFILE "${CMAKE_SHARED_LINKER_FLAGS_RELEASE}") +set(CMAKE_C_FLAGS_PROFILE "${CMAKE_C_FLAGS_RELEASE}") +set(CMAKE_CXX_FLAGS_PROFILE "${CMAKE_CXX_FLAGS_RELEASE}") + +# Use Unicode for all projects. +add_definitions(-DUNICODE -D_UNICODE) + +# Compilation settings that should be applied to most targets. +# +# Be cautious about adding new options here, as plugins use this function by +# default. In most cases, you should add new options to specific targets instead +# of modifying this function. +function(APPLY_STANDARD_SETTINGS TARGET) + target_compile_features(${TARGET} PUBLIC cxx_std_17) + target_compile_options(${TARGET} PRIVATE /W4 /WX /wd"4100") + target_compile_options(${TARGET} PRIVATE /EHsc) + target_compile_definitions(${TARGET} PRIVATE "_HAS_EXCEPTIONS=0") + target_compile_definitions(${TARGET} PRIVATE "$<$:_DEBUG>") +endfunction() + +# Flutter library and tool build rules. +set(FLUTTER_MANAGED_DIR "${CMAKE_CURRENT_SOURCE_DIR}/flutter") +add_subdirectory(${FLUTTER_MANAGED_DIR}) + +# Application build; see runner/CMakeLists.txt. +add_subdirectory("runner") + + +# Generated plugin build rules, which manage building the plugins and adding +# them to the application. +include(flutter/generated_plugins.cmake) + + +# === Installation === +# Support files are copied into place next to the executable, so that it can +# run in place. This is done instead of making a separate bundle (as on Linux) +# so that building and running from within Visual Studio will work. +set(BUILD_BUNDLE_DIR "$") +# Make the "install" step default, as it's required to run. +set(CMAKE_VS_INCLUDE_INSTALL_TO_DEFAULT_BUILD 1) +if(CMAKE_INSTALL_PREFIX_INITIALIZED_TO_DEFAULT) + set(CMAKE_INSTALL_PREFIX "${BUILD_BUNDLE_DIR}" CACHE PATH "..." FORCE) +endif() + +set(INSTALL_BUNDLE_DATA_DIR "${CMAKE_INSTALL_PREFIX}/data") +set(INSTALL_BUNDLE_LIB_DIR "${CMAKE_INSTALL_PREFIX}") + +install(TARGETS ${BINARY_NAME} RUNTIME DESTINATION "${CMAKE_INSTALL_PREFIX}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_ICU_DATA_FILE}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + COMPONENT Runtime) + +install(FILES "${FLUTTER_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +if(PLUGIN_BUNDLED_LIBRARIES) + install(FILES "${PLUGIN_BUNDLED_LIBRARIES}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) +endif() + +# Copy the native assets provided by the build.dart from all packages. +set(NATIVE_ASSETS_DIR "${PROJECT_BUILD_DIR}native_assets/windows/") +install(DIRECTORY "${NATIVE_ASSETS_DIR}" + DESTINATION "${INSTALL_BUNDLE_LIB_DIR}" + COMPONENT Runtime) + +# Fully re-copy the assets directory on each build to avoid having stale files +# from a previous install. +set(FLUTTER_ASSET_DIR_NAME "flutter_assets") +install(CODE " + file(REMOVE_RECURSE \"${INSTALL_BUNDLE_DATA_DIR}/${FLUTTER_ASSET_DIR_NAME}\") + " COMPONENT Runtime) +install(DIRECTORY "${PROJECT_BUILD_DIR}/${FLUTTER_ASSET_DIR_NAME}" + DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" COMPONENT Runtime) + +# Install the AOT library on non-Debug builds only. +install(FILES "${AOT_LIBRARY}" DESTINATION "${INSTALL_BUNDLE_DATA_DIR}" + CONFIGURATIONS Profile;Release + COMPONENT Runtime) diff --git a/packages/native/auth/native_auth_flutter/example/windows/flutter/CMakeLists.txt b/packages/native/auth/native_auth_flutter/example/windows/flutter/CMakeLists.txt new file mode 100644 index 0000000..903f489 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/flutter/CMakeLists.txt @@ -0,0 +1,109 @@ +# This file controls Flutter-level build steps. It should not be edited. +cmake_minimum_required(VERSION 3.14) + +set(EPHEMERAL_DIR "${CMAKE_CURRENT_SOURCE_DIR}/ephemeral") + +# Configuration provided via flutter tool. +include(${EPHEMERAL_DIR}/generated_config.cmake) + +# TODO: Move the rest of this into files in ephemeral. See +# https://github.com/flutter/flutter/issues/57146. +set(WRAPPER_ROOT "${EPHEMERAL_DIR}/cpp_client_wrapper") + +# Set fallback configurations for older versions of the flutter tool. +if (NOT DEFINED FLUTTER_TARGET_PLATFORM) + set(FLUTTER_TARGET_PLATFORM "windows-x64") +endif() + +# === Flutter Library === +set(FLUTTER_LIBRARY "${EPHEMERAL_DIR}/flutter_windows.dll") + +# Published to parent scope for install step. +set(FLUTTER_LIBRARY ${FLUTTER_LIBRARY} PARENT_SCOPE) +set(FLUTTER_ICU_DATA_FILE "${EPHEMERAL_DIR}/icudtl.dat" PARENT_SCOPE) +set(PROJECT_BUILD_DIR "${PROJECT_DIR}/build/" PARENT_SCOPE) +set(AOT_LIBRARY "${PROJECT_DIR}/build/windows/app.so" PARENT_SCOPE) + +list(APPEND FLUTTER_LIBRARY_HEADERS + "flutter_export.h" + "flutter_windows.h" + "flutter_messenger.h" + "flutter_plugin_registrar.h" + "flutter_texture_registrar.h" +) +list(TRANSFORM FLUTTER_LIBRARY_HEADERS PREPEND "${EPHEMERAL_DIR}/") +add_library(flutter INTERFACE) +target_include_directories(flutter INTERFACE + "${EPHEMERAL_DIR}" +) +target_link_libraries(flutter INTERFACE "${FLUTTER_LIBRARY}.lib") +add_dependencies(flutter flutter_assemble) + +# === Wrapper === +list(APPEND CPP_WRAPPER_SOURCES_CORE + "core_implementations.cc" + "standard_codec.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_CORE PREPEND "${WRAPPER_ROOT}/") +list(APPEND CPP_WRAPPER_SOURCES_PLUGIN + "plugin_registrar.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_PLUGIN PREPEND "${WRAPPER_ROOT}/") +list(APPEND CPP_WRAPPER_SOURCES_APP + "flutter_engine.cc" + "flutter_view_controller.cc" +) +list(TRANSFORM CPP_WRAPPER_SOURCES_APP PREPEND "${WRAPPER_ROOT}/") + +# Wrapper sources needed for a plugin. +add_library(flutter_wrapper_plugin STATIC + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_PLUGIN} +) +apply_standard_settings(flutter_wrapper_plugin) +set_target_properties(flutter_wrapper_plugin PROPERTIES + POSITION_INDEPENDENT_CODE ON) +set_target_properties(flutter_wrapper_plugin PROPERTIES + CXX_VISIBILITY_PRESET hidden) +target_link_libraries(flutter_wrapper_plugin PUBLIC flutter) +target_include_directories(flutter_wrapper_plugin PUBLIC + "${WRAPPER_ROOT}/include" +) +add_dependencies(flutter_wrapper_plugin flutter_assemble) + +# Wrapper sources needed for the runner. +add_library(flutter_wrapper_app STATIC + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_APP} +) +apply_standard_settings(flutter_wrapper_app) +target_link_libraries(flutter_wrapper_app PUBLIC flutter) +target_include_directories(flutter_wrapper_app PUBLIC + "${WRAPPER_ROOT}/include" +) +add_dependencies(flutter_wrapper_app flutter_assemble) + +# === Flutter tool backend === +# _phony_ is a non-existent file to force this command to run every time, +# since currently there's no way to get a full input/output list from the +# flutter tool. +set(PHONY_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/_phony_") +set_source_files_properties("${PHONY_OUTPUT}" PROPERTIES SYMBOLIC TRUE) +add_custom_command( + OUTPUT ${FLUTTER_LIBRARY} ${FLUTTER_LIBRARY_HEADERS} + ${CPP_WRAPPER_SOURCES_CORE} ${CPP_WRAPPER_SOURCES_PLUGIN} + ${CPP_WRAPPER_SOURCES_APP} + ${PHONY_OUTPUT} + COMMAND ${CMAKE_COMMAND} -E env + ${FLUTTER_TOOL_ENVIRONMENT} + "${FLUTTER_ROOT}/packages/flutter_tools/bin/tool_backend.bat" + ${FLUTTER_TARGET_PLATFORM} $ + VERBATIM +) +add_custom_target(flutter_assemble DEPENDS + "${FLUTTER_LIBRARY}" + ${FLUTTER_LIBRARY_HEADERS} + ${CPP_WRAPPER_SOURCES_CORE} + ${CPP_WRAPPER_SOURCES_PLUGIN} + ${CPP_WRAPPER_SOURCES_APP} +) diff --git a/packages/native/auth/native_auth_flutter/example/windows/flutter/generated_plugin_registrant.cc b/packages/native/auth/native_auth_flutter/example/windows/flutter/generated_plugin_registrant.cc new file mode 100644 index 0000000..8b6d468 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/flutter/generated_plugin_registrant.cc @@ -0,0 +1,11 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#include "generated_plugin_registrant.h" + + +void RegisterPlugins(flutter::PluginRegistry* registry) { +} diff --git a/packages/native/auth/native_auth_flutter/example/windows/flutter/generated_plugin_registrant.h b/packages/native/auth/native_auth_flutter/example/windows/flutter/generated_plugin_registrant.h new file mode 100644 index 0000000..dc139d8 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/flutter/generated_plugin_registrant.h @@ -0,0 +1,15 @@ +// +// Generated file. Do not edit. +// + +// clang-format off + +#ifndef GENERATED_PLUGIN_REGISTRANT_ +#define GENERATED_PLUGIN_REGISTRANT_ + +#include + +// Registers Flutter plugins. +void RegisterPlugins(flutter::PluginRegistry* registry); + +#endif // GENERATED_PLUGIN_REGISTRANT_ diff --git a/packages/native/auth/native_auth_flutter/example/windows/flutter/generated_plugins.cmake b/packages/native/auth/native_auth_flutter/example/windows/flutter/generated_plugins.cmake new file mode 100644 index 0000000..3ad69c6 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/flutter/generated_plugins.cmake @@ -0,0 +1,24 @@ +# +# Generated file, do not edit. +# + +list(APPEND FLUTTER_PLUGIN_LIST +) + +list(APPEND FLUTTER_FFI_PLUGIN_LIST + jni +) + +set(PLUGIN_BUNDLED_LIBRARIES) + +foreach(plugin ${FLUTTER_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${plugin}/windows plugins/${plugin}) + target_link_libraries(${BINARY_NAME} PRIVATE ${plugin}_plugin) + list(APPEND PLUGIN_BUNDLED_LIBRARIES $) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${plugin}_bundled_libraries}) +endforeach(plugin) + +foreach(ffi_plugin ${FLUTTER_FFI_PLUGIN_LIST}) + add_subdirectory(flutter/ephemeral/.plugin_symlinks/${ffi_plugin}/windows plugins/${ffi_plugin}) + list(APPEND PLUGIN_BUNDLED_LIBRARIES ${${ffi_plugin}_bundled_libraries}) +endforeach(ffi_plugin) diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/CMakeLists.txt b/packages/native/auth/native_auth_flutter/example/windows/runner/CMakeLists.txt new file mode 100644 index 0000000..394917c --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/CMakeLists.txt @@ -0,0 +1,40 @@ +cmake_minimum_required(VERSION 3.14) +project(runner LANGUAGES CXX) + +# Define the application target. To change its name, change BINARY_NAME in the +# top-level CMakeLists.txt, not the value here, or `flutter run` will no longer +# work. +# +# Any new source files that you add to the application should be added here. +add_executable(${BINARY_NAME} WIN32 + "flutter_window.cpp" + "main.cpp" + "utils.cpp" + "win32_window.cpp" + "${FLUTTER_MANAGED_DIR}/generated_plugin_registrant.cc" + "Runner.rc" + "runner.exe.manifest" +) + +# Apply the standard set of build settings. This can be removed for applications +# that need different build settings. +apply_standard_settings(${BINARY_NAME}) + +# Add preprocessor definitions for the build version. +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION=\"${FLUTTER_VERSION}\"") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MAJOR=${FLUTTER_VERSION_MAJOR}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_MINOR=${FLUTTER_VERSION_MINOR}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_PATCH=${FLUTTER_VERSION_PATCH}") +target_compile_definitions(${BINARY_NAME} PRIVATE "FLUTTER_VERSION_BUILD=${FLUTTER_VERSION_BUILD}") + +# Disable Windows macros that collide with C++ standard library functions. +target_compile_definitions(${BINARY_NAME} PRIVATE "NOMINMAX") + +# Add dependency libraries and include directories. Add any application-specific +# dependencies here. +target_link_libraries(${BINARY_NAME} PRIVATE flutter flutter_wrapper_app) +target_link_libraries(${BINARY_NAME} PRIVATE "dwmapi.lib") +target_include_directories(${BINARY_NAME} PRIVATE "${CMAKE_SOURCE_DIR}") + +# Run the Flutter tool portions of the build. This must not be removed. +add_dependencies(${BINARY_NAME} flutter_assemble) diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/Runner.rc b/packages/native/auth/native_auth_flutter/example/windows/runner/Runner.rc new file mode 100644 index 0000000..781b799 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/Runner.rc @@ -0,0 +1,121 @@ +// Microsoft Visual C++ generated resource script. +// +#pragma code_page(65001) +#include "resource.h" + +#define APSTUDIO_READONLY_SYMBOLS +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 2 resource. +// +#include "winres.h" + +///////////////////////////////////////////////////////////////////////////// +#undef APSTUDIO_READONLY_SYMBOLS + +///////////////////////////////////////////////////////////////////////////// +// English (United States) resources + +#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU) +LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US + +#ifdef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// TEXTINCLUDE +// + +1 TEXTINCLUDE +BEGIN + "resource.h\0" +END + +2 TEXTINCLUDE +BEGIN + "#include ""winres.h""\r\n" + "\0" +END + +3 TEXTINCLUDE +BEGIN + "\r\n" + "\0" +END + +#endif // APSTUDIO_INVOKED + + +///////////////////////////////////////////////////////////////////////////// +// +// Icon +// + +// Icon with lowest ID value placed first to ensure application icon +// remains consistent on all systems. +IDI_APP_ICON ICON "resources\\app_icon.ico" + + +///////////////////////////////////////////////////////////////////////////// +// +// Version +// + +#if defined(FLUTTER_VERSION_MAJOR) && defined(FLUTTER_VERSION_MINOR) && defined(FLUTTER_VERSION_PATCH) && defined(FLUTTER_VERSION_BUILD) +#define VERSION_AS_NUMBER FLUTTER_VERSION_MAJOR,FLUTTER_VERSION_MINOR,FLUTTER_VERSION_PATCH,FLUTTER_VERSION_BUILD +#else +#define VERSION_AS_NUMBER 1,0,0,0 +#endif + +#if defined(FLUTTER_VERSION) +#define VERSION_AS_STRING FLUTTER_VERSION +#else +#define VERSION_AS_STRING "1.0.0" +#endif + +VS_VERSION_INFO VERSIONINFO + FILEVERSION VERSION_AS_NUMBER + PRODUCTVERSION VERSION_AS_NUMBER + FILEFLAGSMASK VS_FFI_FILEFLAGSMASK +#ifdef _DEBUG + FILEFLAGS VS_FF_DEBUG +#else + FILEFLAGS 0x0L +#endif + FILEOS VOS__WINDOWS32 + FILETYPE VFT_APP + FILESUBTYPE 0x0L +BEGIN + BLOCK "StringFileInfo" + BEGIN + BLOCK "040904e4" + BEGIN + VALUE "CompanyName", "dev.celest" "\0" + VALUE "FileDescription", "example" "\0" + VALUE "FileVersion", VERSION_AS_STRING "\0" + VALUE "InternalName", "example" "\0" + VALUE "LegalCopyright", "Copyright (C) 2024 dev.celest. All rights reserved." "\0" + VALUE "OriginalFilename", "example.exe" "\0" + VALUE "ProductName", "example" "\0" + VALUE "ProductVersion", VERSION_AS_STRING "\0" + END + END + BLOCK "VarFileInfo" + BEGIN + VALUE "Translation", 0x409, 1252 + END +END + +#endif // English (United States) resources +///////////////////////////////////////////////////////////////////////////// + + + +#ifndef APSTUDIO_INVOKED +///////////////////////////////////////////////////////////////////////////// +// +// Generated from the TEXTINCLUDE 3 resource. +// + + +///////////////////////////////////////////////////////////////////////////// +#endif // not APSTUDIO_INVOKED diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/flutter_window.cpp b/packages/native/auth/native_auth_flutter/example/windows/runner/flutter_window.cpp new file mode 100644 index 0000000..955ee30 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/flutter_window.cpp @@ -0,0 +1,71 @@ +#include "flutter_window.h" + +#include + +#include "flutter/generated_plugin_registrant.h" + +FlutterWindow::FlutterWindow(const flutter::DartProject& project) + : project_(project) {} + +FlutterWindow::~FlutterWindow() {} + +bool FlutterWindow::OnCreate() { + if (!Win32Window::OnCreate()) { + return false; + } + + RECT frame = GetClientArea(); + + // The size here must match the window dimensions to avoid unnecessary surface + // creation / destruction in the startup path. + flutter_controller_ = std::make_unique( + frame.right - frame.left, frame.bottom - frame.top, project_); + // Ensure that basic setup of the controller was successful. + if (!flutter_controller_->engine() || !flutter_controller_->view()) { + return false; + } + RegisterPlugins(flutter_controller_->engine()); + SetChildContent(flutter_controller_->view()->GetNativeWindow()); + + flutter_controller_->engine()->SetNextFrameCallback([&]() { + this->Show(); + }); + + // Flutter can complete the first frame before the "show window" callback is + // registered. The following call ensures a frame is pending to ensure the + // window is shown. It is a no-op if the first frame hasn't completed yet. + flutter_controller_->ForceRedraw(); + + return true; +} + +void FlutterWindow::OnDestroy() { + if (flutter_controller_) { + flutter_controller_ = nullptr; + } + + Win32Window::OnDestroy(); +} + +LRESULT +FlutterWindow::MessageHandler(HWND hwnd, UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + // Give Flutter, including plugins, an opportunity to handle window messages. + if (flutter_controller_) { + std::optional result = + flutter_controller_->HandleTopLevelWindowProc(hwnd, message, wparam, + lparam); + if (result) { + return *result; + } + } + + switch (message) { + case WM_FONTCHANGE: + flutter_controller_->engine()->ReloadSystemFonts(); + break; + } + + return Win32Window::MessageHandler(hwnd, message, wparam, lparam); +} diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/flutter_window.h b/packages/native/auth/native_auth_flutter/example/windows/runner/flutter_window.h new file mode 100644 index 0000000..6da0652 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/flutter_window.h @@ -0,0 +1,33 @@ +#ifndef RUNNER_FLUTTER_WINDOW_H_ +#define RUNNER_FLUTTER_WINDOW_H_ + +#include +#include + +#include + +#include "win32_window.h" + +// A window that does nothing but host a Flutter view. +class FlutterWindow : public Win32Window { + public: + // Creates a new FlutterWindow hosting a Flutter view running |project|. + explicit FlutterWindow(const flutter::DartProject& project); + virtual ~FlutterWindow(); + + protected: + // Win32Window: + bool OnCreate() override; + void OnDestroy() override; + LRESULT MessageHandler(HWND window, UINT const message, WPARAM const wparam, + LPARAM const lparam) noexcept override; + + private: + // The project to run. + flutter::DartProject project_; + + // The Flutter instance hosted by this window. + std::unique_ptr flutter_controller_; +}; + +#endif // RUNNER_FLUTTER_WINDOW_H_ diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/main.cpp b/packages/native/auth/native_auth_flutter/example/windows/runner/main.cpp new file mode 100644 index 0000000..a61bf80 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/main.cpp @@ -0,0 +1,43 @@ +#include +#include +#include + +#include "flutter_window.h" +#include "utils.h" + +int APIENTRY wWinMain(_In_ HINSTANCE instance, _In_opt_ HINSTANCE prev, + _In_ wchar_t *command_line, _In_ int show_command) { + // Attach to console when present (e.g., 'flutter run') or create a + // new console when running with a debugger. + if (!::AttachConsole(ATTACH_PARENT_PROCESS) && ::IsDebuggerPresent()) { + CreateAndAttachConsole(); + } + + // Initialize COM, so that it is available for use in the library and/or + // plugins. + ::CoInitializeEx(nullptr, COINIT_APARTMENTTHREADED); + + flutter::DartProject project(L"data"); + + std::vector command_line_arguments = + GetCommandLineArguments(); + + project.set_dart_entrypoint_arguments(std::move(command_line_arguments)); + + FlutterWindow window(project); + Win32Window::Point origin(10, 10); + Win32Window::Size size(1280, 720); + if (!window.Create(L"example", origin, size)) { + return EXIT_FAILURE; + } + window.SetQuitOnClose(true); + + ::MSG msg; + while (::GetMessage(&msg, nullptr, 0, 0)) { + ::TranslateMessage(&msg); + ::DispatchMessage(&msg); + } + + ::CoUninitialize(); + return EXIT_SUCCESS; +} diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/resource.h b/packages/native/auth/native_auth_flutter/example/windows/runner/resource.h new file mode 100644 index 0000000..66a65d1 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/resource.h @@ -0,0 +1,16 @@ +//{{NO_DEPENDENCIES}} +// Microsoft Visual C++ generated include file. +// Used by Runner.rc +// +#define IDI_APP_ICON 101 + +// Next default values for new objects +// +#ifdef APSTUDIO_INVOKED +#ifndef APSTUDIO_READONLY_SYMBOLS +#define _APS_NEXT_RESOURCE_VALUE 102 +#define _APS_NEXT_COMMAND_VALUE 40001 +#define _APS_NEXT_CONTROL_VALUE 1001 +#define _APS_NEXT_SYMED_VALUE 101 +#endif +#endif diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/resources/app_icon.ico b/packages/native/auth/native_auth_flutter/example/windows/runner/resources/app_icon.ico new file mode 100644 index 0000000..c04e20c Binary files /dev/null and b/packages/native/auth/native_auth_flutter/example/windows/runner/resources/app_icon.ico differ diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/runner.exe.manifest b/packages/native/auth/native_auth_flutter/example/windows/runner/runner.exe.manifest new file mode 100644 index 0000000..153653e --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/runner.exe.manifest @@ -0,0 +1,14 @@ + + + + + PerMonitorV2 + + + + + + + + + diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/utils.cpp b/packages/native/auth/native_auth_flutter/example/windows/runner/utils.cpp new file mode 100644 index 0000000..3a0b465 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/utils.cpp @@ -0,0 +1,65 @@ +#include "utils.h" + +#include +#include +#include +#include + +#include + +void CreateAndAttachConsole() { + if (::AllocConsole()) { + FILE *unused; + if (freopen_s(&unused, "CONOUT$", "w", stdout)) { + _dup2(_fileno(stdout), 1); + } + if (freopen_s(&unused, "CONOUT$", "w", stderr)) { + _dup2(_fileno(stdout), 2); + } + std::ios::sync_with_stdio(); + FlutterDesktopResyncOutputStreams(); + } +} + +std::vector GetCommandLineArguments() { + // Convert the UTF-16 command line arguments to UTF-8 for the Engine to use. + int argc; + wchar_t** argv = ::CommandLineToArgvW(::GetCommandLineW(), &argc); + if (argv == nullptr) { + return std::vector(); + } + + std::vector command_line_arguments; + + // Skip the first argument as it's the binary name. + for (int i = 1; i < argc; i++) { + command_line_arguments.push_back(Utf8FromUtf16(argv[i])); + } + + ::LocalFree(argv); + + return command_line_arguments; +} + +std::string Utf8FromUtf16(const wchar_t* utf16_string) { + if (utf16_string == nullptr) { + return std::string(); + } + unsigned int target_length = ::WideCharToMultiByte( + CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, + -1, nullptr, 0, nullptr, nullptr) + -1; // remove the trailing null character + int input_length = (int)wcslen(utf16_string); + std::string utf8_string; + if (target_length == 0 || target_length > utf8_string.max_size()) { + return utf8_string; + } + utf8_string.resize(target_length); + int converted_length = ::WideCharToMultiByte( + CP_UTF8, WC_ERR_INVALID_CHARS, utf16_string, + input_length, utf8_string.data(), target_length, nullptr, nullptr); + if (converted_length == 0) { + return std::string(); + } + return utf8_string; +} diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/utils.h b/packages/native/auth/native_auth_flutter/example/windows/runner/utils.h new file mode 100644 index 0000000..3879d54 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/utils.h @@ -0,0 +1,19 @@ +#ifndef RUNNER_UTILS_H_ +#define RUNNER_UTILS_H_ + +#include +#include + +// Creates a console for the process, and redirects stdout and stderr to +// it for both the runner and the Flutter library. +void CreateAndAttachConsole(); + +// Takes a null-terminated wchar_t* encoded in UTF-16 and returns a std::string +// encoded in UTF-8. Returns an empty std::string on failure. +std::string Utf8FromUtf16(const wchar_t* utf16_string); + +// Gets the command line arguments passed in as a std::vector, +// encoded in UTF-8. Returns an empty std::vector on failure. +std::vector GetCommandLineArguments(); + +#endif // RUNNER_UTILS_H_ diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/win32_window.cpp b/packages/native/auth/native_auth_flutter/example/windows/runner/win32_window.cpp new file mode 100644 index 0000000..60608d0 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/win32_window.cpp @@ -0,0 +1,288 @@ +#include "win32_window.h" + +#include +#include + +#include "resource.h" + +namespace { + +/// Window attribute that enables dark mode window decorations. +/// +/// Redefined in case the developer's machine has a Windows SDK older than +/// version 10.0.22000.0. +/// See: https://docs.microsoft.com/windows/win32/api/dwmapi/ne-dwmapi-dwmwindowattribute +#ifndef DWMWA_USE_IMMERSIVE_DARK_MODE +#define DWMWA_USE_IMMERSIVE_DARK_MODE 20 +#endif + +constexpr const wchar_t kWindowClassName[] = L"FLUTTER_RUNNER_WIN32_WINDOW"; + +/// Registry key for app theme preference. +/// +/// A value of 0 indicates apps should use dark mode. A non-zero or missing +/// value indicates apps should use light mode. +constexpr const wchar_t kGetPreferredBrightnessRegKey[] = + L"Software\\Microsoft\\Windows\\CurrentVersion\\Themes\\Personalize"; +constexpr const wchar_t kGetPreferredBrightnessRegValue[] = L"AppsUseLightTheme"; + +// The number of Win32Window objects that currently exist. +static int g_active_window_count = 0; + +using EnableNonClientDpiScaling = BOOL __stdcall(HWND hwnd); + +// Scale helper to convert logical scaler values to physical using passed in +// scale factor +int Scale(int source, double scale_factor) { + return static_cast(source * scale_factor); +} + +// Dynamically loads the |EnableNonClientDpiScaling| from the User32 module. +// This API is only needed for PerMonitor V1 awareness mode. +void EnableFullDpiSupportIfAvailable(HWND hwnd) { + HMODULE user32_module = LoadLibraryA("User32.dll"); + if (!user32_module) { + return; + } + auto enable_non_client_dpi_scaling = + reinterpret_cast( + GetProcAddress(user32_module, "EnableNonClientDpiScaling")); + if (enable_non_client_dpi_scaling != nullptr) { + enable_non_client_dpi_scaling(hwnd); + } + FreeLibrary(user32_module); +} + +} // namespace + +// Manages the Win32Window's window class registration. +class WindowClassRegistrar { + public: + ~WindowClassRegistrar() = default; + + // Returns the singleton registrar instance. + static WindowClassRegistrar* GetInstance() { + if (!instance_) { + instance_ = new WindowClassRegistrar(); + } + return instance_; + } + + // Returns the name of the window class, registering the class if it hasn't + // previously been registered. + const wchar_t* GetWindowClass(); + + // Unregisters the window class. Should only be called if there are no + // instances of the window. + void UnregisterWindowClass(); + + private: + WindowClassRegistrar() = default; + + static WindowClassRegistrar* instance_; + + bool class_registered_ = false; +}; + +WindowClassRegistrar* WindowClassRegistrar::instance_ = nullptr; + +const wchar_t* WindowClassRegistrar::GetWindowClass() { + if (!class_registered_) { + WNDCLASS window_class{}; + window_class.hCursor = LoadCursor(nullptr, IDC_ARROW); + window_class.lpszClassName = kWindowClassName; + window_class.style = CS_HREDRAW | CS_VREDRAW; + window_class.cbClsExtra = 0; + window_class.cbWndExtra = 0; + window_class.hInstance = GetModuleHandle(nullptr); + window_class.hIcon = + LoadIcon(window_class.hInstance, MAKEINTRESOURCE(IDI_APP_ICON)); + window_class.hbrBackground = 0; + window_class.lpszMenuName = nullptr; + window_class.lpfnWndProc = Win32Window::WndProc; + RegisterClass(&window_class); + class_registered_ = true; + } + return kWindowClassName; +} + +void WindowClassRegistrar::UnregisterWindowClass() { + UnregisterClass(kWindowClassName, nullptr); + class_registered_ = false; +} + +Win32Window::Win32Window() { + ++g_active_window_count; +} + +Win32Window::~Win32Window() { + --g_active_window_count; + Destroy(); +} + +bool Win32Window::Create(const std::wstring& title, + const Point& origin, + const Size& size) { + Destroy(); + + const wchar_t* window_class = + WindowClassRegistrar::GetInstance()->GetWindowClass(); + + const POINT target_point = {static_cast(origin.x), + static_cast(origin.y)}; + HMONITOR monitor = MonitorFromPoint(target_point, MONITOR_DEFAULTTONEAREST); + UINT dpi = FlutterDesktopGetDpiForMonitor(monitor); + double scale_factor = dpi / 96.0; + + HWND window = CreateWindow( + window_class, title.c_str(), WS_OVERLAPPEDWINDOW, + Scale(origin.x, scale_factor), Scale(origin.y, scale_factor), + Scale(size.width, scale_factor), Scale(size.height, scale_factor), + nullptr, nullptr, GetModuleHandle(nullptr), this); + + if (!window) { + return false; + } + + UpdateTheme(window); + + return OnCreate(); +} + +bool Win32Window::Show() { + return ShowWindow(window_handle_, SW_SHOWNORMAL); +} + +// static +LRESULT CALLBACK Win32Window::WndProc(HWND const window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + if (message == WM_NCCREATE) { + auto window_struct = reinterpret_cast(lparam); + SetWindowLongPtr(window, GWLP_USERDATA, + reinterpret_cast(window_struct->lpCreateParams)); + + auto that = static_cast(window_struct->lpCreateParams); + EnableFullDpiSupportIfAvailable(window); + that->window_handle_ = window; + } else if (Win32Window* that = GetThisFromHandle(window)) { + return that->MessageHandler(window, message, wparam, lparam); + } + + return DefWindowProc(window, message, wparam, lparam); +} + +LRESULT +Win32Window::MessageHandler(HWND hwnd, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept { + switch (message) { + case WM_DESTROY: + window_handle_ = nullptr; + Destroy(); + if (quit_on_close_) { + PostQuitMessage(0); + } + return 0; + + case WM_DPICHANGED: { + auto newRectSize = reinterpret_cast(lparam); + LONG newWidth = newRectSize->right - newRectSize->left; + LONG newHeight = newRectSize->bottom - newRectSize->top; + + SetWindowPos(hwnd, nullptr, newRectSize->left, newRectSize->top, newWidth, + newHeight, SWP_NOZORDER | SWP_NOACTIVATE); + + return 0; + } + case WM_SIZE: { + RECT rect = GetClientArea(); + if (child_content_ != nullptr) { + // Size and position the child window. + MoveWindow(child_content_, rect.left, rect.top, rect.right - rect.left, + rect.bottom - rect.top, TRUE); + } + return 0; + } + + case WM_ACTIVATE: + if (child_content_ != nullptr) { + SetFocus(child_content_); + } + return 0; + + case WM_DWMCOLORIZATIONCOLORCHANGED: + UpdateTheme(hwnd); + return 0; + } + + return DefWindowProc(window_handle_, message, wparam, lparam); +} + +void Win32Window::Destroy() { + OnDestroy(); + + if (window_handle_) { + DestroyWindow(window_handle_); + window_handle_ = nullptr; + } + if (g_active_window_count == 0) { + WindowClassRegistrar::GetInstance()->UnregisterWindowClass(); + } +} + +Win32Window* Win32Window::GetThisFromHandle(HWND const window) noexcept { + return reinterpret_cast( + GetWindowLongPtr(window, GWLP_USERDATA)); +} + +void Win32Window::SetChildContent(HWND content) { + child_content_ = content; + SetParent(content, window_handle_); + RECT frame = GetClientArea(); + + MoveWindow(content, frame.left, frame.top, frame.right - frame.left, + frame.bottom - frame.top, true); + + SetFocus(child_content_); +} + +RECT Win32Window::GetClientArea() { + RECT frame; + GetClientRect(window_handle_, &frame); + return frame; +} + +HWND Win32Window::GetHandle() { + return window_handle_; +} + +void Win32Window::SetQuitOnClose(bool quit_on_close) { + quit_on_close_ = quit_on_close; +} + +bool Win32Window::OnCreate() { + // No-op; provided for subclasses. + return true; +} + +void Win32Window::OnDestroy() { + // No-op; provided for subclasses. +} + +void Win32Window::UpdateTheme(HWND const window) { + DWORD light_mode; + DWORD light_mode_size = sizeof(light_mode); + LSTATUS result = RegGetValue(HKEY_CURRENT_USER, kGetPreferredBrightnessRegKey, + kGetPreferredBrightnessRegValue, + RRF_RT_REG_DWORD, nullptr, &light_mode, + &light_mode_size); + + if (result == ERROR_SUCCESS) { + BOOL enable_dark_mode = light_mode == 0; + DwmSetWindowAttribute(window, DWMWA_USE_IMMERSIVE_DARK_MODE, + &enable_dark_mode, sizeof(enable_dark_mode)); + } +} diff --git a/packages/native/auth/native_auth_flutter/example/windows/runner/win32_window.h b/packages/native/auth/native_auth_flutter/example/windows/runner/win32_window.h new file mode 100644 index 0000000..e901dde --- /dev/null +++ b/packages/native/auth/native_auth_flutter/example/windows/runner/win32_window.h @@ -0,0 +1,102 @@ +#ifndef RUNNER_WIN32_WINDOW_H_ +#define RUNNER_WIN32_WINDOW_H_ + +#include + +#include +#include +#include + +// A class abstraction for a high DPI-aware Win32 Window. Intended to be +// inherited from by classes that wish to specialize with custom +// rendering and input handling +class Win32Window { + public: + struct Point { + unsigned int x; + unsigned int y; + Point(unsigned int x, unsigned int y) : x(x), y(y) {} + }; + + struct Size { + unsigned int width; + unsigned int height; + Size(unsigned int width, unsigned int height) + : width(width), height(height) {} + }; + + Win32Window(); + virtual ~Win32Window(); + + // Creates a win32 window with |title| that is positioned and sized using + // |origin| and |size|. New windows are created on the default monitor. Window + // sizes are specified to the OS in physical pixels, hence to ensure a + // consistent size this function will scale the inputted width and height as + // as appropriate for the default monitor. The window is invisible until + // |Show| is called. Returns true if the window was created successfully. + bool Create(const std::wstring& title, const Point& origin, const Size& size); + + // Show the current window. Returns true if the window was successfully shown. + bool Show(); + + // Release OS resources associated with window. + void Destroy(); + + // Inserts |content| into the window tree. + void SetChildContent(HWND content); + + // Returns the backing Window handle to enable clients to set icon and other + // window properties. Returns nullptr if the window has been destroyed. + HWND GetHandle(); + + // If true, closing this window will quit the application. + void SetQuitOnClose(bool quit_on_close); + + // Return a RECT representing the bounds of the current client area. + RECT GetClientArea(); + + protected: + // Processes and route salient window messages for mouse handling, + // size change and DPI. Delegates handling of these to member overloads that + // inheriting classes can handle. + virtual LRESULT MessageHandler(HWND window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept; + + // Called when CreateAndShow is called, allowing subclass window-related + // setup. Subclasses should return false if setup fails. + virtual bool OnCreate(); + + // Called when Destroy is called. + virtual void OnDestroy(); + + private: + friend class WindowClassRegistrar; + + // OS callback called by message pump. Handles the WM_NCCREATE message which + // is passed when the non-client area is being created and enables automatic + // non-client DPI scaling so that the non-client area automatically + // responds to changes in DPI. All other messages are handled by + // MessageHandler. + static LRESULT CALLBACK WndProc(HWND const window, + UINT const message, + WPARAM const wparam, + LPARAM const lparam) noexcept; + + // Retrieves a class instance pointer for |window| + static Win32Window* GetThisFromHandle(HWND const window) noexcept; + + // Update the window frame's theme to match the system theme. + static void UpdateTheme(HWND const window); + + bool quit_on_close_ = false; + + // window handle for top level window. + HWND window_handle_ = nullptr; + + // window handle for hosted content. + HWND child_content_ = nullptr; +}; + +#endif // RUNNER_WIN32_WINDOW_H_ diff --git a/packages/native/auth/native_auth_flutter/ffigen.ios.yaml b/packages/native/auth/native_auth_flutter/ffigen.ios.yaml new file mode 100644 index 0000000..6d09704 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/ffigen.ios.yaml @@ -0,0 +1,48 @@ +name: AuthenticationServicesIos +description: | + Bindings for AuthenticationServices on iOS. + + Regenerate bindings with `dart run ffigen --config=ffigen.ios.yaml`. +language: "objc" +output: + bindings: "lib/src/native/ios/authentication_services.ffi.dart" + objc-bindings: "ios/Classes/AuthenticationServices.ffi.m" +compiler-opts: + - "-F/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Cryptexes/OS/System/Library/Frameworks" + - "-F/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Library/Frameworks" + - "-miphonesimulator-version-min=17.5" + - "-isysroot" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk" +headers: + entry-points: + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIApplication.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Headers/ASFoundation.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Headers/ASWebAuthenticationSession.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Headers/ASWebAuthenticationSessionCallback.h" + include-directives: + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Library/Frameworks/Foundation.framework/Headers/Foundation.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIKit.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Library/Frameworks/UIKit.framework/Headers/UIApplication.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Headers/ASFoundation.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Headers/ASWebAuthenticationSession.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS17.5.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Headers/ASWebAuthenticationSessionCallback.h" +preamble: | + // ignore_for_file: type=lint + // ignore_for_file: return_of_invalid_type +comments: + style: any + length: full + +exclude-all-by-default: true +objc-interfaces: + include: + - UIApplication + - UIWindow + - AS.* +objc-protocols: + include: + - AS.* +enums: + include: + - AS.* diff --git a/packages/native/auth/native_auth_flutter/ffigen.macos.yaml b/packages/native/auth/native_auth_flutter/ffigen.macos.yaml new file mode 100644 index 0000000..bd260a1 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/ffigen.macos.yaml @@ -0,0 +1,50 @@ +name: AuthenticationServicesMacOS +description: | + Bindings for AuthenticationServices on macOS. + + Regenerate bindings with `dart run ffigen --config=ffigen.macos.yaml`. +language: "objc" +output: + bindings: "lib/src/native/macos/authentication_services.ffi.dart" + objc-bindings: "macos/Classes/AuthenticationServices.ffi.m" +compiler-opts: + - "-F/System/Volumes/Data/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks" + - "-F/System/Volumes/Data/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Cryptexes/OS/System/Library/Frameworks" + - "-mmacosx-version-min=14.5" + - "-isysroot" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk" +headers: + entry-points: + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/AppKit.framework/Versions/C/Headers/NSApplication.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/AppKit.framework/Versions/C/Headers/NSWindow.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Versions/A/Headers/ASFoundation.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Versions/A/Headers/ASWebAuthenticationSession.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Versions/A/Headers/ASWebAuthenticationSessionCallback.h" + include-directives: + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/Foundation.framework/Versions/C/Headers/Foundation.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/AppKit.framework/Versions/C/Headers/AppKit.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/AppKit.framework/Versions/C/Headers/NSApplication.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Library/Frameworks/AppKit.framework/Versions/C/Headers/NSWindow.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Versions/A/Headers/ASFoundation.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Versions/A/Headers/ASWebAuthenticationSession.h" + - "/Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk/System/Cryptexes/OS/System/Library/Frameworks/AuthenticationServices.framework/Versions/A/Headers/ASWebAuthenticationSessionCallback.h" +preamble: | + // ignore_for_file: type=lint + // ignore_for_file: return_of_invalid_type +comments: + style: any + length: full + +exclude-all-by-default: true +objc-interfaces: + include: + - NSApplication + - NSWindow + - AS.* +objc-protocols: + include: + - NSApplicationDelegate + - AS.* +enums: + include: + - AS.* diff --git a/packages/native/auth/native_auth_flutter/ios/Classes/AuthenticationServices.ffi.m b/packages/native/auth/native_auth_flutter/ios/Classes/AuthenticationServices.ffi.m new file mode 100644 index 0000000..a371e13 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/ios/Classes/AuthenticationServices.ffi.m @@ -0,0 +1,98 @@ +#include + +#import +#import +#import +#import +#import +#import + +typedef void (^ListenerBlock)(NSTimer* ); +ListenerBlock wrapListenerBlock_ObjCBlock_ffiVoid_NSTimer(ListenerBlock block) { + ListenerBlock wrapper = [^void(NSTimer* arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock1)(UIImage* ); +ListenerBlock1 wrapListenerBlock_ObjCBlock_ffiVoid_UIImage(ListenerBlock1 block) { + ListenerBlock1 wrapper = [^void(UIImage* arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock2)(id ); +ListenerBlock2 wrapListenerBlock_ObjCBlock_ffiVoid_objcObjCObject(ListenerBlock2 block) { + ListenerBlock2 wrapper = [^void(id arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock3)(NSError* ); +ListenerBlock3 wrapListenerBlock_ObjCBlock_ffiVoid_NSError(ListenerBlock3 block) { + ListenerBlock3 wrapper = [^void(NSError* arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock4)(UIAction* ); +ListenerBlock4 wrapListenerBlock_ObjCBlock_ffiVoid_UIAction(ListenerBlock4 block) { + ListenerBlock4 wrapper = [^void(UIAction* arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock5)(UIAction* , id , void * , UIControlEvents , BOOL * ); +ListenerBlock5 wrapListenerBlock_ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool(ListenerBlock5 block) { + ListenerBlock5 wrapper = [^void(UIAction* arg0, id arg1, void * arg2, UIControlEvents arg3, BOOL * arg4) { + block([arg0 retain], [arg1 retain], arg2, arg3, arg4); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock6)(NSInputStream* , NSOutputStream* , NSError* ); +ListenerBlock6 wrapListenerBlock_ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError(ListenerBlock6 block) { + ListenerBlock6 wrapper = [^void(NSInputStream* arg0, NSOutputStream* arg1, NSError* arg2) { + block([arg0 retain], [arg1 retain], [arg2 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock7)(NSDate* , BOOL , BOOL * ); +ListenerBlock7 wrapListenerBlock_ObjCBlock_ffiVoid_NSDate_bool_bool(ListenerBlock7 block) { + ListenerBlock7 wrapper = [^void(NSDate* arg0, BOOL arg1, BOOL * arg2) { + block([arg0 retain], arg1, arg2); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock8)(NSError* ); +ListenerBlock8 wrapListenerBlock_ObjCBlock_ffiVoid_NSError1(ListenerBlock8 block) { + ListenerBlock8 wrapper = [^void(NSError* arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock9)(NSURL* , NSError* ); +ListenerBlock9 wrapListenerBlock_ObjCBlock_ffiVoid_NSURL_NSError(ListenerBlock9 block) { + ListenerBlock9 wrapper = [^void(NSURL* arg0, NSError* arg1) { + block([arg0 retain], [arg1 retain]); + } copy]; + [block release]; + return wrapper; +} diff --git a/packages/native/auth/native_auth_flutter/ios/native_auth_flutter.podspec b/packages/native/auth/native_auth_flutter/ios/native_auth_flutter.podspec new file mode 100644 index 0000000..86082cd --- /dev/null +++ b/packages/native/auth/native_auth_flutter/ios/native_auth_flutter.podspec @@ -0,0 +1,21 @@ +Pod::Spec.new do |s| + s.name = 'native_auth_flutter' + s.version = '0.0.1' + s.summary = 'Native support for package:native_auth_flutter' + s.description = <<-DESC +Wraps ASWebAuthenticationSession for iOS. + DESC + s.homepage = 'https://celest.dev' + s.license = { :file => '../LICENSE' } + s.author = { 'Celest' => 'contact@celest.dev' } + + s.platform = :ios, '13.0' + s.swift_version = '5.0' + s.dependency 'Flutter' + + s.source = { :path => '.' } + s.source_files = 'Classes/**/*' + s.compiler_flags = ['-fno-objc-arc'] + + s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' } +end diff --git a/packages/native/auth/native_auth_flutter/jnigen.yaml b/packages/native/auth/native_auth_flutter/jnigen.yaml new file mode 100644 index 0000000..7083510 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/jnigen.yaml @@ -0,0 +1,30 @@ +# Regenerate bindings with `dart run jnigen --config jnigen.yaml`. + +android_sdk_config: + add_gradle_deps: true + android_example: "example/" + +suspend_fun_to_async: true +enable_experiment: + - "interface_implementation" + +output: + dart: + path: "lib/src/native/android/jni_bindings.ffi.dart" + structure: single_file + +classes: + - dev.celest.native_auth.NativeAuth + - dev.celest.native_auth.NativeAuthCallback + - dev.celest.native_auth.NativeAuthRedirectSession + - dev.celest.native_auth.NativeAuthRedirectResult + - io.flutter.embedding.android.FlutterActivity + + - java.lang.Runnable + - java.lang.Exception + - java.lang.Throwable + - android.app.Activity + - android.content.Context + - android.net.Uri + - android.os.Bundle + - android.os.CancellationSignal diff --git a/packages/native/auth/native_auth_flutter/lib/native_auth_flutter.dart b/packages/native/auth/native_auth_flutter/lib/native_auth_flutter.dart new file mode 100644 index 0000000..035f3e0 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/native_auth_flutter.dart @@ -0,0 +1,40 @@ +import 'package:logging/logging.dart'; +import 'package:meta/meta.dart'; +import 'package:native_auth_flutter/src/model/callback_scheme.dart'; +import 'package:native_auth_flutter/src/model/callback_session.dart'; +import 'package:native_auth_flutter/src/native_auth.platform_stub.dart' + if (dart.library.js_interop) 'package:native_auth_flutter/src/native_auth.platform_web.dart' + if (dart.library.io) 'package:native_auth_flutter/src/native_auth.platform_io.dart'; + +export 'src/model/callback_scheme.dart'; +export 'src/model/callback_session.dart' show NativeAuthCallbackSession; +export 'src/model/exception.dart'; +export 'src/model/oauth_result.dart'; + +abstract interface class NativeAuth { + factory NativeAuth({ + Logger? logger, + }) => + NativeAuthPlatform(logger: logger); + + /// Starts the OAuth authorization flow by redirecting the user to the given + /// [signInUri]. + /// + /// Unlike [performAuthorizationRedirect], which waits for the user to be + /// redirected back to the [callbackScheme], this method returns a session + /// object that can be used to await or cancel the authorization flow. + @useResult + NativeAuthCallbackSession startAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }); + + /// Performs an authorization redirect to the given [uri] and waits for the + /// user to be redirected back to the [callbackScheme]. + /// + /// Returns the URI that the user was redirected to. + Future performAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }); +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/model/callback_scheme.dart b/packages/native/auth/native_auth_flutter/lib/src/model/callback_scheme.dart new file mode 100644 index 0000000..14f12b2 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/model/callback_scheme.dart @@ -0,0 +1,120 @@ +/// {@template native_auth.redirect_scheme} +/// The scheme to use for monitoring redirects from an authorization server. +/// {@endtemplate} +sealed class CallbackScheme { + /// {@macro native_auth.redirect_scheme} + const CallbackScheme(); + + /// {@macro native_auth.redirect_localhost_scheme} + const factory CallbackScheme.localhost({ + int port, + String path, + }) = CallbackSchemeLocalhost; + + /// {@macro native_auth.redirect_https_scheme} + const factory CallbackScheme.https({ + required String host, + required String path, + }) = CallbackSchemeHttps; + + /// {@macro native_auth.redirect_custom_scheme} + const factory CallbackScheme.custom( + String scheme, { + String host, + String path, + }) = CallbackSchemeCustom; +} + +/// {@template native_auth.redirect_localhost_scheme} +/// Uses `http://localhost` for the redirect URI. +/// +/// Platform support: macOS, Windows, Linux +/// {@endtemplate} +final class CallbackSchemeLocalhost extends CallbackScheme { + /// {@macro native_auth.redirect_localhost_scheme} + const CallbackSchemeLocalhost({this.port = 0, this.path = '/*'}); + + /// The port to use for the local server. + /// + /// If not provided, this defaults to `0`, which will use an ephemeral port. + /// When using ephemeral ports, make sure your authorization server is + /// configured to allow wildcard ports. + final int port; + + /// The path to listen on for redirects. + /// + /// If not provided, this defaults to `/*`, which will listen on all paths. + /// Typically, you would want to configure this as an added layer of security + /// or if your authorization server requires a specific path. + final String path; + + @override + String toString() { + return 'http://localhost:$port'; + } +} + +/// {@template native_auth.redirect_https_scheme} +/// Uses an HTTPS scheme for the redirect URI. +/// +/// The HTTPS scheme must point to a [host] that you own and is registered to +/// your application via the respective platform mechanisms. +/// +/// Platform support: Android, iOS (17.4+), macOS (14.4+), Web +/// {@endtemplate} +final class CallbackSchemeHttps extends CallbackScheme { + /// {@macro native_auth.redirect_https_scheme} + const CallbackSchemeHttps({ + required this.host, + required this.path, + }) : assert(path != '', 'path must not be empty'); + + /// The host (domain) to use for the redirect URI, e.g. `example.com`. + final String host; + + /// The path to use for the redirect URI, e.g. `/auth`. + /// + /// Unlike other redirect schemes, the path must be set to a specific value. + final String path; + + @override + String toString() { + return 'https://$host$path'; + } +} + +/// {@template native_auth.redirect_custom_scheme} +/// Uses a custom scheme for the redirect URI. +/// +/// Platform support: iOS, macOS, Android +/// {@endtemplate} +final class CallbackSchemeCustom extends CallbackScheme { + /// {@macro native_auth.redirect_custom_scheme} + const CallbackSchemeCustom( + this.scheme, { + this.host = '*', + this.path = '/*', + }); + + /// The custom scheme to use for the redirect URI. + final String scheme; + + /// The host to listen on for redirects. + /// + /// If not provided, this defaults to `*`, which will listen on all hosts. + /// Typically, you will want to configure this and/or [path] when the + /// [scheme] is not sufficient to uniquely identify your app. + final String host; + + /// The path to listen on for redirects. + /// + /// If not provided, this defaults to `/*`, which will listen on all paths. + /// Typically, you will want to configure this and/or [host] when the + /// [scheme] is not sufficient to uniquely identify your app. + final String path; + + @override + String toString() { + return '$scheme:$host$path'; + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/model/callback_session.dart b/packages/native/auth/native_auth_flutter/lib/src/model/callback_session.dart new file mode 100644 index 0000000..554bd31 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/model/callback_session.dart @@ -0,0 +1,48 @@ +import 'dart:async'; +import 'dart:math'; + +import 'package:meta/meta.dart'; + +/// A session object that represents an ongoing authorization flow. +sealed class NativeAuthCallbackSession { + /// The unique identifier of this session. + int get id; + + /// The URI that the user was redirected to. + Future get redirectUri; + + /// Cancels the authorization flow. + void cancel(); + + @override + int get hashCode => Object.hash(NativeAuthCallbackSession, id); + + @override + bool operator ==(Object other) => + other is NativeAuthCallbackSession && other.id == id; +} + +@internal +final class NativeAuthCallbackSessionImpl extends NativeAuthCallbackSession { + NativeAuthCallbackSessionImpl( + this.id, + this._completer, + this._cancel, + ); + + static final Random _random = Random(); + + @internal + static int nextId() => _random.nextInt(1 << 10); + + @override + final int id; + final Completer _completer; + final void Function() _cancel; + + @override + Future get redirectUri => _completer.future; + + @override + void cancel() => _cancel(); +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/model/exception.dart b/packages/native/auth/native_auth_flutter/lib/src/model/exception.dart new file mode 100644 index 0000000..d37579c --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/model/exception.dart @@ -0,0 +1,45 @@ +/// {@template native_auth.native_auth_exception} +/// An exception thrown during the native authentication process. +/// +/// If present, [underlyingError] contains the original error that caused this +/// exception, usually from the platform itself. +/// {@endtemplate} +abstract interface class NativeAuthException { + /// Creates a new [NativeAuthException] with the given [message] and optional + /// [underlyingError]. + /// + /// {@macro native_auth.native_auth_exception} + const factory NativeAuthException( + String message, { + Object? underlyingError, + }) = _NativeAuthExceptionImpl; + + /// The error message. + String get message; + + /// The original error that caused this exception, typically from the platform + /// itself. + Object? get underlyingError; +} + +class _NativeAuthExceptionImpl implements NativeAuthException { + const _NativeAuthExceptionImpl( + this.message, { + this.underlyingError, + }); + + @override + final String message; + + @override + final Object? underlyingError; + + @override + String toString() { + if (underlyingError != null) { + return '$message: $underlyingError'; + } else { + return message; + } + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/model/oauth_result.dart b/packages/native/auth/native_auth_flutter/lib/src/model/oauth_result.dart new file mode 100644 index 0000000..e11888f --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/model/oauth_result.dart @@ -0,0 +1,384 @@ +import 'package:native_auth_flutter/src/model/exception.dart'; + +/// Error codes of a failed OAuth flow. +/// +/// References: +/// - [OAuth 2.0 Error Codes](https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.2.1) +/// - [OIDC Error Codes](https://openid.net/specs/openid-connect-core-1_0.html#AuthError) +extension type const OAuthErrorCode(String wireName) implements String { + /// The request is missing a required parameter, includes an invalid parameter + /// value, includes a parameter more than once, or is otherwise malformed. + static const OAuthErrorCode invalidRequest = + OAuthErrorCode('invalid_request'); + + /// The client is not authorized to request an authorization code using this + /// method. + static const OAuthErrorCode unauthorizedClient = + OAuthErrorCode('unauthorized_client'); + + /// The resource owner or authorization server denied the request. + static const OAuthErrorCode accessDenied = OAuthErrorCode('access_denied'); + + /// The authorization server does not support obtaining an authorization code + /// using this method. + static const OAuthErrorCode unsupportedResponseType = + OAuthErrorCode('unsupported_response_type'); + + /// The requested scope is invalid, unknown, or malformed. + static const OAuthErrorCode invalidScope = OAuthErrorCode('invalid_scope'); + + /// The authorization server encountered an unexpected condition that + /// prevented it from fulfilling the request. + /// + /// (This error code is needed because a 500 Internal Server Error HTTP status + /// code cannot be returned to the client via an HTTP redirect.) + static const OAuthErrorCode serverError = OAuthErrorCode('server_error'); + + /// The authorization server is currently unable to handle the request due to + /// a temporary overloading or maintenance of the server. + /// + /// (This error code is needed because a 503 Service Unavailable HTTP status + /// code cannot be returned to the client via an HTTP redirect.) + static const OAuthErrorCode temporarilyUnavailable = + OAuthErrorCode('temporarily_unavailable'); + + /// The Authorization Server requires End-User interaction of some form to + /// proceed. + /// + /// This error MAY be returned when the `prompt` parameter value in the + /// Authentication Request is `none`, but the Authentication Request cannot be + /// completed without displaying a user interface for End-User interaction. + static const OAuthErrorCode interactionRequired = + OAuthErrorCode('interaction_required'); + + /// The Authorization Server requires End-User authentication. + /// + /// This error MAY be returned when the `prompt` parameter value in the + /// Authentication Request is `none`, but the Authentication Request cannot be + /// completed without displaying a user interface for End-User authentication. + static const OAuthErrorCode loginRequired = OAuthErrorCode('login_required'); + + /// The End-User is REQUIRED to select a session at the Authorization Server. + /// + /// The End-User MAY be authenticated at the Authorization Server with + /// different associated accounts, but the End-User did not select a session. + /// This error MAY be returned when the `prompt` parameter value in the + /// Authentication Request is `none`, but the Authentication Request cannot be + /// completed without displaying a user interface to prompt for a session to + /// use. + static const OAuthErrorCode accountSelectionRequired = + OAuthErrorCode('account_selection_required'); + + /// The Authorization Server requires End-User consent. + /// + /// This error MAY be returned when the `prompt` parameter value in the + /// Authentication Request is `none`, but the Authentication Request cannot be + /// completed without displaying a user interface for End-User consent. + static const OAuthErrorCode consentRequired = + OAuthErrorCode('consent_required'); + + /// The OP does not support use of the `request` parameter defined in + /// [Section 6](https://openid.net/specs/openid-connect-core-1_0.html#JWTRequests). + static const OAuthErrorCode requestNotSupported = + OAuthErrorCode('request_not_supported'); + + /// The assertion presented is invalid. + /// + /// https://datatracker.ietf.org/doc/html/rfc6749#section-5.2 + /// https://datatracker.ietf.org/doc/html/rfc7521#section-4.2.1 + static const OAuthErrorCode invalidClient = OAuthErrorCode('invalid_client'); + + /// The provided authorization grant (e.g., authorization code, resource owner + /// credentials) or refresh token is invalid, expired, revoked, does not match + /// the redirection URI used in the authorization request, or was issued to + /// another client. + /// + /// https://datatracker.ietf.org/doc/html/rfc6749#section-5.2 + static const OAuthErrorCode invalidGrant = OAuthErrorCode('invalid_grant'); + + /// The authenticated client is not authorized to use this authorization grant + /// type. + static const OAuthErrorCode unsupportedGrantType = + OAuthErrorCode('unsupported_grant_type'); + + // Additional error codes as defined in + // https://www.rfc-editor.org/rfc/rfc8628#section-3.5 + // Device Access Token Response + + /// The authorization request is still pending as the end user hasn't yet + /// completed the user-interaction steps. + /// + /// https://www.rfc-editor.org/rfc/rfc8628#section-3.5 + static const OAuthErrorCode authorizationPending = + OAuthErrorCode('authorization_pending'); + + /// A variant of "authorization_pending", the authorization request is still + /// pending and polling should continue, but the interval MUST be increased + /// by 5 seconds for this and all subsequent requests. + /// + /// https://www.rfc-editor.org/rfc/rfc8628#section-3.5 + static const OAuthErrorCode slowDown = OAuthErrorCode('slow_down'); + + /// The "device_code" has expired, and the device authorization session has + /// concluded. The client MAY commence a new device authorization request but + /// SHOULD wait for user interaction before restarting to avoid unnecessary + /// polling. + /// + /// https://www.rfc-editor.org/rfc/rfc8628#section-3.5 + static const OAuthErrorCode expiredToken = OAuthErrorCode('expired_token'); + + // InvalidTarget error is returned by Token Exchange if + // the requested target or audience is invalid. + // [RFC 8693, Section 2.2.2: Error Response](https://www.rfc-editor.org/rfc/rfc8693#section-2.2.2) + + /// The requested target or audience is invalid. + /// + /// ://www.rfc-editor.org/rfc/rfc8693#section-2.2.2 + static const OAuthErrorCode invalidTarget = OAuthErrorCode('invalid_target'); + + /// The user-facing description of the error. + String get description => switch (this) { + invalidRequest => + 'The request is missing a required parameter, includes an ' + 'invalid parameter value, includes a parameter more than once, or ' + 'is otherwise malformed.', + unauthorizedClient => + 'The client is not authorized to request an authorization code using ' + 'this method.', + accessDenied => + 'The resource owner or authorization server denied the request.', + unsupportedResponseType => + 'The authorization server does not support obtaining an authorization ' + 'code using this method.', + invalidScope => + 'The requested scope is invalid, unknown, or malformed.', + serverError => + 'The authorization server encountered an unexpected condition that ' + 'prevented it from fulfilling the request.', + temporarilyUnavailable => + 'The authorization server is currently unable to handle the request ' + 'due to a temporary overloading or maintenance of the server.', + interactionRequired => + 'The authorization server requires user interaction of some form to ' + 'proceed. This error is typically returned when a user is not ' + 'authenticated, or when consent is needed.', + loginRequired => + 'The authorization server requires the user to log in. This error is ' + 'typically returned when a user is not authenticated.', + accountSelectionRequired => + 'The authorization server requires the user to select a user account. ' + 'This error is typically returned when a user is authenticated but ' + 'needs to select a user account.', + consentRequired => + 'The authorization server requires the user to consent to a request. ' + 'This error is typically returned when a user is authenticated but ' + 'has not consented to a request.', + requestNotSupported => + 'The authorization server does not support the request. This error ' + 'is typically returned when an authorization server does not support ' + 'a requested feature, such as `prompt=none`.', + invalidClient => + 'Client authentication failed (e.g., unknown client, no client ' + 'authentication included, or unsupported authentication method).', + invalidGrant => + 'The provided authorization grant (e.g., authorization code, resource ' + 'owner credentials) or refresh token is invalid, expired, revoked, ' + 'does not match the redirection URI used in the authorization request, ' + 'or was issued to another client.', + unsupportedGrantType => + 'The authorization grant type is not supported by the authorization ' + 'server.', + authorizationPending => + 'The authorization request is still pending as the end-user has not ' + 'yet completed the user interaction steps.', + slowDown => + 'The client should slow down the poll requests to the token endpoint.', + expiredToken => 'The authorization server has expired the token.', + invalidTarget => 'The requested target or audience is invalid.', + _ => 'An unknown error occurred.', + }; +} + +/// {@template native_auth.oauth_parameters} +/// Query parameters of the OAuth redirect. +/// +/// [Reference](https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.2) +/// {@endtemplate} +sealed class OAuthResult { + /// Parses [json] into an [OAuthResult] object. + factory OAuthResult.fromJson(Map json) { + json = json.map((key, value) { + return MapEntry( + key, + // On some platforms, these are still encoded at this point. + value is String ? Uri.decodeQueryComponent(value) : '', + ); + }); + return switch (json) { + {'state': final String state, 'code': final String code} => OAuthCode( + state: state, + code: code, + ), + { + 'state': final String state, + 'error': final String error, + 'error_description': final String? errorDescription, + 'error_uri': final String? errorUri + } => + OAuthException( + state: state, + error: OAuthErrorCode(error), + errorDescription: errorDescription, + errorUri: errorUri, + ), + _ => throw ArgumentError.value( + json, + 'json', + 'Invalid OAuth parameters. Expected one of `code` or `error`.', + ), + }; + } + + /// Parses OAuth parameters from a [uri]. + factory OAuthResult.fromUri(Uri uri) { + final parameters = {...uri.queryParameters}; + + // Handle fragment as well e.g. /#/auth?code=...&state=... + final fragment = uri.fragment; + final parts = fragment.split('?'); + if (parts.length == 2) { + parameters.addAll(Uri.splitQueryString(parts[1])); + } + + // Only a redirect if it contains this combination of parameters. + // https://www.rfc-editor.org/rfc/rfc6749#section-4.1.2 + // https://www.rfc-editor.org/rfc/rfc6749#section-4.1.3 + if (parameters.containsKey('code') || parameters.containsKey('error')) { + return OAuthResult.fromJson(parameters); + } + + throw ArgumentError.value( + uri, + 'uri', + 'Invalid OAuth redirect URI. Expected either `code` or `error`.', + ); + } + + /// The exact state parameter received from the client. + /// + /// Required for requests that included a state parameter. + String? get state; + + /// REQUIRED. The authorization code generated by the authorization server. + /// + /// The authorization code MUST expire shortly after it is issued to mitigate + /// the risk of leaks. A maximum authorization code lifetime of 10 minutes is + /// RECOMMENDED. The client MUST NOT use the authorization code more than + /// once. If an authorization code is used more than once, the authorization + /// server MUST deny the request and SHOULD revoke (when possible) all tokens + /// previously issued based on that authorization code. The authorization code + /// is bound to the client identifier and redirection URI. + String? get code; + + /// The error parameter. + /// + /// **Required** for error responses. + /// + /// [Reference](https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.2.1) + OAuthErrorCode? get error; + + /// The error_description parameter. + /// + /// **Optional** for error responses. + /// + /// [Reference](https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.2.1) + String? get errorDescription; + + /// The error_uri parameter. + /// + /// **Optional** for error responses. + /// + /// [Reference](https://datatracker.ietf.org/doc/html/rfc6749#section-4.1.2.1) + String? get errorUri; + + /// The JSON representation of `this`. + Map toJson(); +} + +final class OAuthCode implements OAuthResult { + const OAuthCode({ + this.state, + required this.code, + }); + + @override + final String? state; + + @override + final String code; + + @override + OAuthErrorCode? get error => null; + + @override + String? get errorDescription => null; + + @override + String? get errorUri => null; + + @override + Map toJson() => { + if (state case final state?) 'state': state, + 'code': code, + }; +} + +final class OAuthException implements OAuthResult, NativeAuthException { + const OAuthException({ + this.state, + required this.error, + this.errorDescription, + this.errorUri, + }); + + @override + final String? state; + + @override + final OAuthErrorCode error; + + @override + final String? errorDescription; + + @override + String get message => errorDescription ?? error.description; + + @override + final String? errorUri; + + @override + String? get code => null; + + @override + Object? get underlyingError => null; + + @override + Map toJson() => { + if (state case final state?) 'state': state, + 'error': error, + if (errorDescription case final errorDescription?) + 'error_description': errorDescription, + if (errorUri case final errorUri?) 'error_uri': errorUri, + }; + + @override + String toString() { + final buffer = StringBuffer('Error in OAuth: $error ($message)'); + if (errorUri != null) { + buffer + ..writeln() + ..write(errorUri); + } + return buffer.toString(); + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/native/android/jni_bindings.ffi.dart b/packages/native/auth/native_auth_flutter/lib/src/native/android/jni_bindings.ffi.dart new file mode 100644 index 0000000..ea8f3b4 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/native/android/jni_bindings.ffi.dart @@ -0,0 +1,21654 @@ +// Autogenerated by jnigen. DO NOT EDIT! + +// ignore_for_file: annotate_overrides +// ignore_for_file: argument_type_not_assignable +// ignore_for_file: camel_case_extensions +// ignore_for_file: camel_case_types +// ignore_for_file: constant_identifier_names +// ignore_for_file: doc_directive_unknown +// ignore_for_file: file_names +// ignore_for_file: lines_longer_than_80_chars +// ignore_for_file: no_leading_underscores_for_local_identifiers +// ignore_for_file: non_constant_identifier_names +// ignore_for_file: only_throw_errors +// ignore_for_file: overridden_fields +// ignore_for_file: prefer_double_quotes +// ignore_for_file: unnecessary_cast +// ignore_for_file: unnecessary_parenthesis +// ignore_for_file: unused_element +// ignore_for_file: unused_field +// ignore_for_file: unused_import +// ignore_for_file: unused_local_variable +// ignore_for_file: unused_shown_name +// ignore_for_file: use_super_parameters + +import 'dart:ffi' as ffi; +import 'dart:isolate' show ReceivePort; + +import 'package:jni/internal_helpers_for_jnigen.dart'; +import 'package:jni/jni.dart' as jni; + +/// from: dev.celest.native_auth.NativeAuth$Companion +class NativeAuth_Companion extends jni.JObject { + @override + late final jni.JObjType $type = type; + + NativeAuth_Companion.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r'dev/celest/native_auth/NativeAuth$Companion'); + + /// The type which includes information such as the signature of this class. + static const type = $NativeAuth_CompanionType(); + static final _id_new0 = _class.constructorId( + r'(Lkotlin/jvm/internal/DefaultConstructorMarker;)V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void (kotlin.jvm.internal.DefaultConstructorMarker defaultConstructorMarker) + /// The returned object must be released after use, by calling the [release] method. + factory NativeAuth_Companion( + jni.JObject defaultConstructorMarker, + ) { + return NativeAuth_Companion.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + defaultConstructorMarker.reference.pointer) + .reference); + } +} + +final class $NativeAuth_CompanionType + extends jni.JObjType { + const $NativeAuth_CompanionType(); + + @override + String get signature => r'Ldev/celest/native_auth/NativeAuth$Companion;'; + + @override + NativeAuth_Companion fromReference(jni.JReference reference) => + NativeAuth_Companion.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($NativeAuth_CompanionType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($NativeAuth_CompanionType) && + other is $NativeAuth_CompanionType; + } +} + +/// from: dev.celest.native_auth.NativeAuth +class NativeAuth extends jni.JObject { + @override + late final jni.JObjType $type = type; + + NativeAuth.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r'dev/celest/native_auth/NativeAuth'); + + /// The type which includes information such as the signature of this class. + static const type = $NativeAuthType(); + static final _id_Companion = _class.staticFieldId( + r'Companion', + r'Ldev/celest/native_auth/NativeAuth$Companion;', + ); + + /// from: static public final dev.celest.native_auth.NativeAuth$Companion Companion + /// The returned object must be released after use, by calling the [release] method. + static NativeAuth_Companion get Companion => + _id_Companion.get(_class, const $NativeAuth_CompanionType()); + + static final _id_KEY_AUTH_INTENT = _class.staticFieldId( + r'KEY_AUTH_INTENT', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String KEY_AUTH_INTENT + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get KEY_AUTH_INTENT => + _id_KEY_AUTH_INTENT.get(_class, const jni.JStringType()); + + static final _id_KEY_AUTHORIZATION_STARTED = _class.staticFieldId( + r'KEY_AUTHORIZATION_STARTED', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String KEY_AUTHORIZATION_STARTED + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get KEY_AUTHORIZATION_STARTED => + _id_KEY_AUTHORIZATION_STARTED.get(_class, const jni.JStringType()); + + static final _id_KEY_AUTH_REQUEST_ID = _class.staticFieldId( + r'KEY_AUTH_REQUEST_ID', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String KEY_AUTH_REQUEST_ID + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get KEY_AUTH_REQUEST_ID => + _id_KEY_AUTH_REQUEST_ID.get(_class, const jni.JStringType()); + + static final _id_KEY_AUTH_REQUEST_URI = _class.staticFieldId( + r'KEY_AUTH_REQUEST_URI', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String KEY_AUTH_REQUEST_URI + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get KEY_AUTH_REQUEST_URI => + _id_KEY_AUTH_REQUEST_URI.get(_class, const jni.JStringType()); + + /// from: static public final int RESULT_OK + static const RESULT_OK = 0; + + /// from: static public final int RESULT_FAILURE + static const RESULT_FAILURE = 1; + + /// from: static public final int RESULT_CANCELED + static const RESULT_CANCELED = 2; + static final _id_new0 = _class.constructorId( + r'(Lio/flutter/embedding/android/FlutterActivity;Ldev/celest/native_auth/NativeAuthCallback;)V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void (io.flutter.embedding.android.FlutterActivity flutterActivity, dev.celest.native_auth.NativeAuthCallback nativeAuthCallback) + /// The returned object must be released after use, by calling the [release] method. + factory NativeAuth( + FlutterActivity flutterActivity, + NativeAuthCallback nativeAuthCallback, + ) { + return NativeAuth.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + flutterActivity.reference.pointer, + nativeAuthCallback.reference.pointer) + .reference); + } + + static final _id_startRedirect = _class.instanceMethodId( + r'startRedirect', + r'(ILandroid/net/Uri;)Landroid/os/CancellationSignal;', + ); + + static final _startRedirect = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public final android.os.CancellationSignal startRedirect(int i, android.net.Uri uri) + /// The returned object must be released after use, by calling the [release] method. + CancellationSignal startRedirect( + int i, + Uri uri, + ) { + return _startRedirect(reference.pointer, + _id_startRedirect as jni.JMethodIDPtr, i, uri.reference.pointer) + .object(const $CancellationSignalType()); + } +} + +final class $NativeAuthType extends jni.JObjType { + const $NativeAuthType(); + + @override + String get signature => r'Ldev/celest/native_auth/NativeAuth;'; + + @override + NativeAuth fromReference(jni.JReference reference) => + NativeAuth.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($NativeAuthType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($NativeAuthType) && other is $NativeAuthType; + } +} + +/// from: dev.celest.native_auth.NativeAuthCallback +class NativeAuthCallback<$T extends jni.JObject> extends jni.JObject { + @override + late final jni.JObjType> $type = type(T); + + final jni.JObjType<$T> T; + + NativeAuthCallback.fromReference( + this.T, + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r'dev/celest/native_auth/NativeAuthCallback'); + + /// The type which includes information such as the signature of this class. + static $NativeAuthCallbackType<$T> type<$T extends jni.JObject>( + jni.JObjType<$T> T, + ) { + return $NativeAuthCallbackType( + T, + ); + } + + static final _id_onMessage = _class.instanceMethodId( + r'onMessage', + r'(Ljava/lang/Object;)V', + ); + + static final _onMessage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void onMessage(T object) + void onMessage( + $T object, + ) { + _onMessage(reference.pointer, _id_onMessage as jni.JMethodIDPtr, + object.reference.pointer) + .check(); + } + + /// Maps a specific port to the implemented interface. + static final Map _$impls = {}; + ReceivePort? _$p; + + static jni.JObjectPtr _$invoke( + int port, + jni.JObjectPtr descriptor, + jni.JObjectPtr args, + ) { + return _$invokeMethod( + port, + $MethodInvocation.fromAddresses( + 0, + descriptor.address, + args.address, + ), + ); + } + + static final ffi.Pointer< + ffi.NativeFunction< + jni.JObjectPtr Function( + ffi.Uint64, jni.JObjectPtr, jni.JObjectPtr)>> + _$invokePointer = ffi.Pointer.fromFunction(_$invoke); + + static ffi.Pointer _$invokeMethod( + int $p, + $MethodInvocation $i, + ) { + try { + final $d = $i.methodDescriptor.toDartString(releaseOriginal: true); + final $a = $i.args; + if ($d == r'onMessage(Ljava/lang/Object;)V') { + _$impls[$p]!.onMessage( + $a[0].castTo(_$impls[$p]!.T, releaseOriginal: true), + ); + return jni.nullptr; + } + } catch (e) { + return ProtectedJniExtensions.newDartException(e); + } + return jni.nullptr; + } + + factory NativeAuthCallback.implement( + $NativeAuthCallbackImpl<$T> $impl, + ) { + final $p = ReceivePort(); + final $x = NativeAuthCallback.fromReference( + $impl.T, + ProtectedJniExtensions.newPortProxy( + r'dev.celest.native_auth.NativeAuthCallback', + $p, + _$invokePointer, + ), + ).._$p = $p; + final $a = $p.sendPort.nativePort; + _$impls[$a] = $impl; + $p.listen(($m) { + if ($m == null) { + _$impls.remove($p.sendPort.nativePort); + $p.close(); + return; + } + final $i = $MethodInvocation.fromMessage($m as List); + final $r = _$invokeMethod($p.sendPort.nativePort, $i); + ProtectedJniExtensions.returnResult($i.result, $r); + }); + return $x; + } +} + +abstract interface class $NativeAuthCallbackImpl<$T extends jni.JObject> { + factory $NativeAuthCallbackImpl({ + required jni.JObjType<$T> T, + required void Function($T object) onMessage, + }) = _$NativeAuthCallbackImpl; + + jni.JObjType<$T> get T; + + void onMessage($T object); +} + +class _$NativeAuthCallbackImpl<$T extends jni.JObject> + implements $NativeAuthCallbackImpl<$T> { + _$NativeAuthCallbackImpl({ + required this.T, + required void Function($T object) onMessage, + }) : _onMessage = onMessage; + + @override + final jni.JObjType<$T> T; + + final void Function($T object) _onMessage; + + void onMessage($T object) { + return _onMessage(object); + } +} + +final class $NativeAuthCallbackType<$T extends jni.JObject> + extends jni.JObjType> { + final jni.JObjType<$T> T; + + const $NativeAuthCallbackType( + this.T, + ); + + @override + String get signature => r'Ldev/celest/native_auth/NativeAuthCallback;'; + + @override + NativeAuthCallback<$T> fromReference(jni.JReference reference) => + NativeAuthCallback.fromReference(T, reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => Object.hash($NativeAuthCallbackType, T); + + @override + bool operator ==(Object other) { + return other.runtimeType == ($NativeAuthCallbackType<$T>) && + other is $NativeAuthCallbackType<$T> && + T == other.T; + } +} + +/// from: dev.celest.native_auth.NativeAuthRedirectSession +class NativeAuthRedirectSession extends jni.JObject { + @override + late final jni.JObjType $type = type; + + NativeAuthRedirectSession.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r'dev/celest/native_auth/NativeAuthRedirectSession'); + + /// The type which includes information such as the signature of this class. + static const type = $NativeAuthRedirectSessionType(); + static final _id_new0 = _class.constructorId( + r'(ILandroid/net/Uri;Landroid/os/CancellationSignal;)V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void (int i, android.net.Uri uri, android.os.CancellationSignal cancellationSignal) + /// The returned object must be released after use, by calling the [release] method. + factory NativeAuthRedirectSession( + int i, + Uri uri, + CancellationSignal cancellationSignal, + ) { + return NativeAuthRedirectSession.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + i, + uri.reference.pointer, + cancellationSignal.reference.pointer) + .reference); + } + + static final _id_getId = _class.instanceMethodId( + r'getId', + r'()I', + ); + + static final _getId = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final int getId() + int getId() { + return _getId(reference.pointer, _id_getId as jni.JMethodIDPtr).integer; + } + + static final _id_getStartUri = _class.instanceMethodId( + r'getStartUri', + r'()Landroid/net/Uri;', + ); + + static final _getStartUri = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.net.Uri getStartUri() + /// The returned object must be released after use, by calling the [release] method. + Uri getStartUri() { + return _getStartUri(reference.pointer, _id_getStartUri as jni.JMethodIDPtr) + .object(const $UriType()); + } + + static final _id_getCancellationSignal = _class.instanceMethodId( + r'getCancellationSignal', + r'()Landroid/os/CancellationSignal;', + ); + + static final _getCancellationSignal = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.os.CancellationSignal getCancellationSignal() + /// The returned object must be released after use, by calling the [release] method. + CancellationSignal getCancellationSignal() { + return _getCancellationSignal( + reference.pointer, _id_getCancellationSignal as jni.JMethodIDPtr) + .object(const $CancellationSignalType()); + } + + static final _id_component1 = _class.instanceMethodId( + r'component1', + r'()I', + ); + + static final _component1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final int component1() + int component1() { + return _component1(reference.pointer, _id_component1 as jni.JMethodIDPtr) + .integer; + } + + static final _id_component2 = _class.instanceMethodId( + r'component2', + r'()Landroid/net/Uri;', + ); + + static final _component2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.net.Uri component2() + /// The returned object must be released after use, by calling the [release] method. + Uri component2() { + return _component2(reference.pointer, _id_component2 as jni.JMethodIDPtr) + .object(const $UriType()); + } + + static final _id_component3 = _class.instanceMethodId( + r'component3', + r'()Landroid/os/CancellationSignal;', + ); + + static final _component3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.os.CancellationSignal component3() + /// The returned object must be released after use, by calling the [release] method. + CancellationSignal component3() { + return _component3(reference.pointer, _id_component3 as jni.JMethodIDPtr) + .object(const $CancellationSignalType()); + } + + static final _id_copy = _class.instanceMethodId( + r'copy', + r'(ILandroid/net/Uri;Landroid/os/CancellationSignal;)Ldev/celest/native_auth/NativeAuthRedirectSession;', + ); + + static final _copy = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public final dev.celest.native_auth.NativeAuthRedirectSession copy(int i, android.net.Uri uri, android.os.CancellationSignal cancellationSignal) + /// The returned object must be released after use, by calling the [release] method. + NativeAuthRedirectSession copy( + int i, + Uri uri, + CancellationSignal cancellationSignal, + ) { + return _copy(reference.pointer, _id_copy as jni.JMethodIDPtr, i, + uri.reference.pointer, cancellationSignal.reference.pointer) + .object(const $NativeAuthRedirectSessionType()); + } + + static final _id_toString1 = _class.instanceMethodId( + r'toString', + r'()Ljava/lang/String;', + ); + + static final _toString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String toString() + /// The returned object must be released after use, by calling the [release] method. + jni.JString toString1() { + return _toString1(reference.pointer, _id_toString1 as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_hashCode1 = _class.instanceMethodId( + r'hashCode', + r'()I', + ); + + static final _hashCode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int hashCode() + int hashCode1() { + return _hashCode1(reference.pointer, _id_hashCode1 as jni.JMethodIDPtr) + .integer; + } + + static final _id_equals = _class.instanceMethodId( + r'equals', + r'(Ljava/lang/Object;)Z', + ); + + static final _equals = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean equals(java.lang.Object object) + bool equals( + jni.JObject object, + ) { + return _equals(reference.pointer, _id_equals as jni.JMethodIDPtr, + object.reference.pointer) + .boolean; + } +} + +final class $NativeAuthRedirectSessionType + extends jni.JObjType { + const $NativeAuthRedirectSessionType(); + + @override + String get signature => r'Ldev/celest/native_auth/NativeAuthRedirectSession;'; + + @override + NativeAuthRedirectSession fromReference(jni.JReference reference) => + NativeAuthRedirectSession.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($NativeAuthRedirectSessionType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($NativeAuthRedirectSessionType) && + other is $NativeAuthRedirectSessionType; + } +} + +/// from: dev.celest.native_auth.NativeAuthRedirectResult +class NativeAuthRedirectResult extends jni.JObject { + @override + late final jni.JObjType $type = type; + + NativeAuthRedirectResult.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r'dev/celest/native_auth/NativeAuthRedirectResult'); + + /// The type which includes information such as the signature of this class. + static const type = $NativeAuthRedirectResultType(); + static final _id_new0 = _class.constructorId( + r'(IILandroid/net/Uri;Ljava/lang/Throwable;)V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + $Int32, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + int, ffi.Pointer, ffi.Pointer)>(); + + /// from: public void (int i, int i1, android.net.Uri uri, java.lang.Throwable throwable) + /// The returned object must be released after use, by calling the [release] method. + factory NativeAuthRedirectResult( + int i, + int i1, + Uri uri, + Throwable throwable, + ) { + return NativeAuthRedirectResult.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + i, + i1, + uri.reference.pointer, + throwable.reference.pointer) + .reference); + } + + static final _id_new1 = _class.constructorId( + r'(IILandroid/net/Uri;Ljava/lang/Throwable;ILkotlin/jvm/internal/DefaultConstructorMarker;)V', + ); + + static final _new1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + $Int32, + $Int32, + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + int, + int, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); + + /// from: public void (int i, int i1, android.net.Uri uri, java.lang.Throwable throwable, int i2, kotlin.jvm.internal.DefaultConstructorMarker defaultConstructorMarker) + /// The returned object must be released after use, by calling the [release] method. + factory NativeAuthRedirectResult.new1( + int i, + int i1, + Uri uri, + Throwable throwable, + int i2, + jni.JObject defaultConstructorMarker, + ) { + return NativeAuthRedirectResult.fromReference(_new1( + _class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, + i, + i1, + uri.reference.pointer, + throwable.reference.pointer, + i2, + defaultConstructorMarker.reference.pointer) + .reference); + } + + static final _id_getId = _class.instanceMethodId( + r'getId', + r'()I', + ); + + static final _getId = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final int getId() + int getId() { + return _getId(reference.pointer, _id_getId as jni.JMethodIDPtr).integer; + } + + static final _id_getResultCode = _class.instanceMethodId( + r'getResultCode', + r'()I', + ); + + static final _getResultCode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final int getResultCode() + int getResultCode() { + return _getResultCode( + reference.pointer, _id_getResultCode as jni.JMethodIDPtr) + .integer; + } + + static final _id_getUri = _class.instanceMethodId( + r'getUri', + r'()Landroid/net/Uri;', + ); + + static final _getUri = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.net.Uri getUri() + /// The returned object must be released after use, by calling the [release] method. + Uri getUri() { + return _getUri(reference.pointer, _id_getUri as jni.JMethodIDPtr) + .object(const $UriType()); + } + + static final _id_getError = _class.instanceMethodId( + r'getError', + r'()Ljava/lang/Throwable;', + ); + + static final _getError = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final java.lang.Throwable getError() + /// The returned object must be released after use, by calling the [release] method. + Throwable getError() { + return _getError(reference.pointer, _id_getError as jni.JMethodIDPtr) + .object(const $ThrowableType()); + } + + static final _id_component1 = _class.instanceMethodId( + r'component1', + r'()I', + ); + + static final _component1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final int component1() + int component1() { + return _component1(reference.pointer, _id_component1 as jni.JMethodIDPtr) + .integer; + } + + static final _id_component2 = _class.instanceMethodId( + r'component2', + r'()I', + ); + + static final _component2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final int component2() + int component2() { + return _component2(reference.pointer, _id_component2 as jni.JMethodIDPtr) + .integer; + } + + static final _id_component3 = _class.instanceMethodId( + r'component3', + r'()Landroid/net/Uri;', + ); + + static final _component3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.net.Uri component3() + /// The returned object must be released after use, by calling the [release] method. + Uri component3() { + return _component3(reference.pointer, _id_component3 as jni.JMethodIDPtr) + .object(const $UriType()); + } + + static final _id_component4 = _class.instanceMethodId( + r'component4', + r'()Ljava/lang/Throwable;', + ); + + static final _component4 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final java.lang.Throwable component4() + /// The returned object must be released after use, by calling the [release] method. + Throwable component4() { + return _component4(reference.pointer, _id_component4 as jni.JMethodIDPtr) + .object(const $ThrowableType()); + } + + static final _id_copy = _class.instanceMethodId( + r'copy', + r'(IILandroid/net/Uri;Ljava/lang/Throwable;)Ldev/celest/native_auth/NativeAuthRedirectResult;', + ); + + static final _copy = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + $Int32, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + int, ffi.Pointer, ffi.Pointer)>(); + + /// from: public final dev.celest.native_auth.NativeAuthRedirectResult copy(int i, int i1, android.net.Uri uri, java.lang.Throwable throwable) + /// The returned object must be released after use, by calling the [release] method. + NativeAuthRedirectResult copy( + int i, + int i1, + Uri uri, + Throwable throwable, + ) { + return _copy(reference.pointer, _id_copy as jni.JMethodIDPtr, i, i1, + uri.reference.pointer, throwable.reference.pointer) + .object(const $NativeAuthRedirectResultType()); + } + + static final _id_toString1 = _class.instanceMethodId( + r'toString', + r'()Ljava/lang/String;', + ); + + static final _toString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String toString() + /// The returned object must be released after use, by calling the [release] method. + jni.JString toString1() { + return _toString1(reference.pointer, _id_toString1 as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_hashCode1 = _class.instanceMethodId( + r'hashCode', + r'()I', + ); + + static final _hashCode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int hashCode() + int hashCode1() { + return _hashCode1(reference.pointer, _id_hashCode1 as jni.JMethodIDPtr) + .integer; + } + + static final _id_equals = _class.instanceMethodId( + r'equals', + r'(Ljava/lang/Object;)Z', + ); + + static final _equals = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean equals(java.lang.Object object) + bool equals( + jni.JObject object, + ) { + return _equals(reference.pointer, _id_equals as jni.JMethodIDPtr, + object.reference.pointer) + .boolean; + } +} + +final class $NativeAuthRedirectResultType + extends jni.JObjType { + const $NativeAuthRedirectResultType(); + + @override + String get signature => r'Ldev/celest/native_auth/NativeAuthRedirectResult;'; + + @override + NativeAuthRedirectResult fromReference(jni.JReference reference) => + NativeAuthRedirectResult.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($NativeAuthRedirectResultType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($NativeAuthRedirectResultType) && + other is $NativeAuthRedirectResultType; + } +} + +/// from: io.flutter.embedding.android.FlutterActivity$CachedEngineIntentBuilder +class FlutterActivity_CachedEngineIntentBuilder extends jni.JObject { + @override + late final jni.JObjType $type = + type; + + FlutterActivity_CachedEngineIntentBuilder.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r'io/flutter/embedding/android/FlutterActivity$CachedEngineIntentBuilder'); + + /// The type which includes information such as the signature of this class. + static const type = $FlutterActivity_CachedEngineIntentBuilderType(); + static final _id_new0 = _class.constructorId( + r'(Ljava/lang/Class;Ljava/lang/String;)V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void (java.lang.Class class, java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + factory FlutterActivity_CachedEngineIntentBuilder( + jni.JObject class0, + jni.JString string, + ) { + return FlutterActivity_CachedEngineIntentBuilder.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + class0.reference.pointer, + string.reference.pointer) + .reference); + } + + static final _id_destroyEngineWithActivity = _class.instanceMethodId( + r'destroyEngineWithActivity', + r'(Z)Lio/flutter/embedding/android/FlutterActivity$CachedEngineIntentBuilder;', + ); + + static final _destroyEngineWithActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public io.flutter.embedding.android.FlutterActivity$CachedEngineIntentBuilder destroyEngineWithActivity(boolean z) + /// The returned object must be released after use, by calling the [release] method. + FlutterActivity_CachedEngineIntentBuilder destroyEngineWithActivity( + bool z, + ) { + return _destroyEngineWithActivity(reference.pointer, + _id_destroyEngineWithActivity as jni.JMethodIDPtr, z ? 1 : 0) + .object(const $FlutterActivity_CachedEngineIntentBuilderType()); + } + + static final _id_backgroundMode = _class.instanceMethodId( + r'backgroundMode', + r'(Lio/flutter/embedding/android/FlutterActivityLaunchConfigs$BackgroundMode;)Lio/flutter/embedding/android/FlutterActivity$CachedEngineIntentBuilder;', + ); + + static final _backgroundMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public io.flutter.embedding.android.FlutterActivity$CachedEngineIntentBuilder backgroundMode(io.flutter.embedding.android.FlutterActivityLaunchConfigs$BackgroundMode backgroundMode) + /// The returned object must be released after use, by calling the [release] method. + FlutterActivity_CachedEngineIntentBuilder backgroundMode( + jni.JObject backgroundMode, + ) { + return _backgroundMode( + reference.pointer, + _id_backgroundMode as jni.JMethodIDPtr, + backgroundMode.reference.pointer) + .object(const $FlutterActivity_CachedEngineIntentBuilderType()); + } + + static final _id_build = _class.instanceMethodId( + r'build', + r'(Landroid/content/Context;)Landroid/content/Intent;', + ); + + static final _build = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.content.Intent build(android.content.Context context) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject build( + Context context, + ) { + return _build(reference.pointer, _id_build as jni.JMethodIDPtr, + context.reference.pointer) + .object(const jni.JObjectType()); + } +} + +final class $FlutterActivity_CachedEngineIntentBuilderType + extends jni.JObjType { + const $FlutterActivity_CachedEngineIntentBuilderType(); + + @override + String get signature => + r'Lio/flutter/embedding/android/FlutterActivity$CachedEngineIntentBuilder;'; + + @override + FlutterActivity_CachedEngineIntentBuilder fromReference( + jni.JReference reference) => + FlutterActivity_CachedEngineIntentBuilder.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($FlutterActivity_CachedEngineIntentBuilderType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == + ($FlutterActivity_CachedEngineIntentBuilderType) && + other is $FlutterActivity_CachedEngineIntentBuilderType; + } +} + +/// from: io.flutter.embedding.android.FlutterActivity$NewEngineInGroupIntentBuilder +class FlutterActivity_NewEngineInGroupIntentBuilder extends jni.JObject { + @override + late final jni.JObjType $type = + type; + + FlutterActivity_NewEngineInGroupIntentBuilder.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r'io/flutter/embedding/android/FlutterActivity$NewEngineInGroupIntentBuilder'); + + /// The type which includes information such as the signature of this class. + static const type = $FlutterActivity_NewEngineInGroupIntentBuilderType(); + static final _id_new0 = _class.constructorId( + r'(Ljava/lang/Class;Ljava/lang/String;)V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void (java.lang.Class class, java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + factory FlutterActivity_NewEngineInGroupIntentBuilder( + jni.JObject class0, + jni.JString string, + ) { + return FlutterActivity_NewEngineInGroupIntentBuilder.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + class0.reference.pointer, + string.reference.pointer) + .reference); + } + + static final _id_dartEntrypoint = _class.instanceMethodId( + r'dartEntrypoint', + r'(Ljava/lang/String;)Lio/flutter/embedding/android/FlutterActivity$NewEngineInGroupIntentBuilder;', + ); + + static final _dartEntrypoint = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public io.flutter.embedding.android.FlutterActivity$NewEngineInGroupIntentBuilder dartEntrypoint(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + FlutterActivity_NewEngineInGroupIntentBuilder dartEntrypoint( + jni.JString string, + ) { + return _dartEntrypoint(reference.pointer, + _id_dartEntrypoint as jni.JMethodIDPtr, string.reference.pointer) + .object(const $FlutterActivity_NewEngineInGroupIntentBuilderType()); + } + + static final _id_initialRoute = _class.instanceMethodId( + r'initialRoute', + r'(Ljava/lang/String;)Lio/flutter/embedding/android/FlutterActivity$NewEngineInGroupIntentBuilder;', + ); + + static final _initialRoute = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public io.flutter.embedding.android.FlutterActivity$NewEngineInGroupIntentBuilder initialRoute(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + FlutterActivity_NewEngineInGroupIntentBuilder initialRoute( + jni.JString string, + ) { + return _initialRoute(reference.pointer, + _id_initialRoute as jni.JMethodIDPtr, string.reference.pointer) + .object(const $FlutterActivity_NewEngineInGroupIntentBuilderType()); + } + + static final _id_backgroundMode = _class.instanceMethodId( + r'backgroundMode', + r'(Lio/flutter/embedding/android/FlutterActivityLaunchConfigs$BackgroundMode;)Lio/flutter/embedding/android/FlutterActivity$NewEngineInGroupIntentBuilder;', + ); + + static final _backgroundMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public io.flutter.embedding.android.FlutterActivity$NewEngineInGroupIntentBuilder backgroundMode(io.flutter.embedding.android.FlutterActivityLaunchConfigs$BackgroundMode backgroundMode) + /// The returned object must be released after use, by calling the [release] method. + FlutterActivity_NewEngineInGroupIntentBuilder backgroundMode( + jni.JObject backgroundMode, + ) { + return _backgroundMode( + reference.pointer, + _id_backgroundMode as jni.JMethodIDPtr, + backgroundMode.reference.pointer) + .object(const $FlutterActivity_NewEngineInGroupIntentBuilderType()); + } + + static final _id_build = _class.instanceMethodId( + r'build', + r'(Landroid/content/Context;)Landroid/content/Intent;', + ); + + static final _build = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.content.Intent build(android.content.Context context) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject build( + Context context, + ) { + return _build(reference.pointer, _id_build as jni.JMethodIDPtr, + context.reference.pointer) + .object(const jni.JObjectType()); + } +} + +final class $FlutterActivity_NewEngineInGroupIntentBuilderType + extends jni.JObjType { + const $FlutterActivity_NewEngineInGroupIntentBuilderType(); + + @override + String get signature => + r'Lio/flutter/embedding/android/FlutterActivity$NewEngineInGroupIntentBuilder;'; + + @override + FlutterActivity_NewEngineInGroupIntentBuilder fromReference( + jni.JReference reference) => + FlutterActivity_NewEngineInGroupIntentBuilder.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => + ($FlutterActivity_NewEngineInGroupIntentBuilderType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == + ($FlutterActivity_NewEngineInGroupIntentBuilderType) && + other is $FlutterActivity_NewEngineInGroupIntentBuilderType; + } +} + +/// from: io.flutter.embedding.android.FlutterActivity$NewEngineIntentBuilder +class FlutterActivity_NewEngineIntentBuilder extends jni.JObject { + @override + late final jni.JObjType $type = type; + + FlutterActivity_NewEngineIntentBuilder.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName( + r'io/flutter/embedding/android/FlutterActivity$NewEngineIntentBuilder'); + + /// The type which includes information such as the signature of this class. + static const type = $FlutterActivity_NewEngineIntentBuilderType(); + static final _id_new0 = _class.constructorId( + r'(Ljava/lang/Class;)V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void (java.lang.Class class) + /// The returned object must be released after use, by calling the [release] method. + factory FlutterActivity_NewEngineIntentBuilder( + jni.JObject class0, + ) { + return FlutterActivity_NewEngineIntentBuilder.fromReference(_new0( + _class.reference.pointer, + _id_new0 as jni.JMethodIDPtr, + class0.reference.pointer) + .reference); + } + + static final _id_initialRoute = _class.instanceMethodId( + r'initialRoute', + r'(Ljava/lang/String;)Lio/flutter/embedding/android/FlutterActivity$NewEngineIntentBuilder;', + ); + + static final _initialRoute = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public io.flutter.embedding.android.FlutterActivity$NewEngineIntentBuilder initialRoute(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + FlutterActivity_NewEngineIntentBuilder initialRoute( + jni.JString string, + ) { + return _initialRoute(reference.pointer, + _id_initialRoute as jni.JMethodIDPtr, string.reference.pointer) + .object(const $FlutterActivity_NewEngineIntentBuilderType()); + } + + static final _id_backgroundMode = _class.instanceMethodId( + r'backgroundMode', + r'(Lio/flutter/embedding/android/FlutterActivityLaunchConfigs$BackgroundMode;)Lio/flutter/embedding/android/FlutterActivity$NewEngineIntentBuilder;', + ); + + static final _backgroundMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public io.flutter.embedding.android.FlutterActivity$NewEngineIntentBuilder backgroundMode(io.flutter.embedding.android.FlutterActivityLaunchConfigs$BackgroundMode backgroundMode) + /// The returned object must be released after use, by calling the [release] method. + FlutterActivity_NewEngineIntentBuilder backgroundMode( + jni.JObject backgroundMode, + ) { + return _backgroundMode( + reference.pointer, + _id_backgroundMode as jni.JMethodIDPtr, + backgroundMode.reference.pointer) + .object(const $FlutterActivity_NewEngineIntentBuilderType()); + } + + static final _id_dartEntrypointArgs = _class.instanceMethodId( + r'dartEntrypointArgs', + r'(Ljava/util/List;)Lio/flutter/embedding/android/FlutterActivity$NewEngineIntentBuilder;', + ); + + static final _dartEntrypointArgs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public io.flutter.embedding.android.FlutterActivity$NewEngineIntentBuilder dartEntrypointArgs(java.util.List list) + /// The returned object must be released after use, by calling the [release] method. + FlutterActivity_NewEngineIntentBuilder dartEntrypointArgs( + jni.JList list, + ) { + return _dartEntrypointArgs(reference.pointer, + _id_dartEntrypointArgs as jni.JMethodIDPtr, list.reference.pointer) + .object(const $FlutterActivity_NewEngineIntentBuilderType()); + } + + static final _id_build = _class.instanceMethodId( + r'build', + r'(Landroid/content/Context;)Landroid/content/Intent;', + ); + + static final _build = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.content.Intent build(android.content.Context context) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject build( + Context context, + ) { + return _build(reference.pointer, _id_build as jni.JMethodIDPtr, + context.reference.pointer) + .object(const jni.JObjectType()); + } +} + +final class $FlutterActivity_NewEngineIntentBuilderType + extends jni.JObjType { + const $FlutterActivity_NewEngineIntentBuilderType(); + + @override + String get signature => + r'Lio/flutter/embedding/android/FlutterActivity$NewEngineIntentBuilder;'; + + @override + FlutterActivity_NewEngineIntentBuilder fromReference( + jni.JReference reference) => + FlutterActivity_NewEngineIntentBuilder.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($FlutterActivity_NewEngineIntentBuilderType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($FlutterActivity_NewEngineIntentBuilderType) && + other is $FlutterActivity_NewEngineIntentBuilderType; + } +} + +/// from: io.flutter.embedding.android.FlutterActivity +class FlutterActivity extends Activity { + @override + late final jni.JObjType $type = type; + + FlutterActivity.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r'io/flutter/embedding/android/FlutterActivity'); + + /// The type which includes information such as the signature of this class. + static const type = $FlutterActivityType(); + static final _id_FLUTTER_VIEW_ID = _class.staticFieldId( + r'FLUTTER_VIEW_ID', + r'I', + ); + + /// from: static public final int FLUTTER_VIEW_ID + static int get FLUTTER_VIEW_ID => + _id_FLUTTER_VIEW_ID.get(_class, const jni.jintType()); + + static final _id_delegate = _class.instanceFieldId( + r'delegate', + r'Lio/flutter/embedding/android/FlutterActivityAndFragmentDelegate;', + ); + + /// from: protected io.flutter.embedding.android.FlutterActivityAndFragmentDelegate delegate + /// The returned object must be released after use, by calling the [release] method. + jni.JObject get delegate => _id_delegate.get(this, const jni.JObjectType()); + + /// from: protected io.flutter.embedding.android.FlutterActivityAndFragmentDelegate delegate + /// The returned object must be released after use, by calling the [release] method. + set delegate(jni.JObject value) => + _id_delegate.set(this, const jni.JObjectType(), value); + + static final _id_createDefaultIntent = _class.staticMethodId( + r'createDefaultIntent', + r'(Landroid/content/Context;)Landroid/content/Intent;', + ); + + static final _createDefaultIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: static public android.content.Intent createDefaultIntent(android.content.Context context) + /// The returned object must be released after use, by calling the [release] method. + static jni.JObject createDefaultIntent( + Context context, + ) { + return _createDefaultIntent( + _class.reference.pointer, + _id_createDefaultIntent as jni.JMethodIDPtr, + context.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_withNewEngine = _class.staticMethodId( + r'withNewEngine', + r'()Lio/flutter/embedding/android/FlutterActivity$NewEngineIntentBuilder;', + ); + + static final _withNewEngine = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: static public io.flutter.embedding.android.FlutterActivity$NewEngineIntentBuilder withNewEngine() + /// The returned object must be released after use, by calling the [release] method. + static FlutterActivity_NewEngineIntentBuilder withNewEngine() { + return _withNewEngine( + _class.reference.pointer, _id_withNewEngine as jni.JMethodIDPtr) + .object(const $FlutterActivity_NewEngineIntentBuilderType()); + } + + static final _id_withCachedEngine = _class.staticMethodId( + r'withCachedEngine', + r'(Ljava/lang/String;)Lio/flutter/embedding/android/FlutterActivity$CachedEngineIntentBuilder;', + ); + + static final _withCachedEngine = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: static public io.flutter.embedding.android.FlutterActivity$CachedEngineIntentBuilder withCachedEngine(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + static FlutterActivity_CachedEngineIntentBuilder withCachedEngine( + jni.JString string, + ) { + return _withCachedEngine(_class.reference.pointer, + _id_withCachedEngine as jni.JMethodIDPtr, string.reference.pointer) + .object(const $FlutterActivity_CachedEngineIntentBuilderType()); + } + + static final _id_withNewEngineInGroup = _class.staticMethodId( + r'withNewEngineInGroup', + r'(Ljava/lang/String;)Lio/flutter/embedding/android/FlutterActivity$NewEngineInGroupIntentBuilder;', + ); + + static final _withNewEngineInGroup = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: static public io.flutter.embedding.android.FlutterActivity$NewEngineInGroupIntentBuilder withNewEngineInGroup(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + static FlutterActivity_NewEngineInGroupIntentBuilder withNewEngineInGroup( + jni.JString string, + ) { + return _withNewEngineInGroup( + _class.reference.pointer, + _id_withNewEngineInGroup as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $FlutterActivity_NewEngineInGroupIntentBuilderType()); + } + + static final _id_new0 = _class.constructorId( + r'()V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void () + /// The returned object must be released after use, by calling the [release] method. + factory FlutterActivity() { + return FlutterActivity.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); + } + + static final _id_getExclusiveAppComponent = _class.instanceMethodId( + r'getExclusiveAppComponent', + r'()Lio/flutter/embedding/android/ExclusiveAppComponent;', + ); + + static final _getExclusiveAppComponent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public io.flutter.embedding.android.ExclusiveAppComponent getExclusiveAppComponent() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getExclusiveAppComponent() { + return _getExclusiveAppComponent( + reference.pointer, _id_getExclusiveAppComponent as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_onCreate = _class.instanceMethodId( + r'onCreate', + r'(Landroid/os/Bundle;)V', + ); + + static final _onCreate = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: protected void onCreate(android.os.Bundle bundle) + void onCreate( + Bundle bundle, + ) { + _onCreate(reference.pointer, _id_onCreate as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); + } + + static final _id_registerOnBackInvokedCallback = _class.instanceMethodId( + r'registerOnBackInvokedCallback', + r'()V', + ); + + static final _registerOnBackInvokedCallback = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void registerOnBackInvokedCallback() + void registerOnBackInvokedCallback() { + _registerOnBackInvokedCallback(reference.pointer, + _id_registerOnBackInvokedCallback as jni.JMethodIDPtr) + .check(); + } + + static final _id_unregisterOnBackInvokedCallback = _class.instanceMethodId( + r'unregisterOnBackInvokedCallback', + r'()V', + ); + + static final _unregisterOnBackInvokedCallback = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void unregisterOnBackInvokedCallback() + void unregisterOnBackInvokedCallback() { + _unregisterOnBackInvokedCallback(reference.pointer, + _id_unregisterOnBackInvokedCallback as jni.JMethodIDPtr) + .check(); + } + + static final _id_getOnBackInvokedCallback = _class.instanceMethodId( + r'getOnBackInvokedCallback', + r'()Landroid/window/OnBackInvokedCallback;', + ); + + static final _getOnBackInvokedCallback = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected android.window.OnBackInvokedCallback getOnBackInvokedCallback() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getOnBackInvokedCallback() { + return _getOnBackInvokedCallback( + reference.pointer, _id_getOnBackInvokedCallback as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_setFrameworkHandlesBack = _class.instanceMethodId( + r'setFrameworkHandlesBack', + r'(Z)V', + ); + + static final _setFrameworkHandlesBack = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setFrameworkHandlesBack(boolean z) + void setFrameworkHandlesBack( + bool z, + ) { + _setFrameworkHandlesBack(reference.pointer, + _id_setFrameworkHandlesBack as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_onStart = _class.instanceMethodId( + r'onStart', + r'()V', + ); + + static final _onStart = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onStart() + void onStart() { + _onStart(reference.pointer, _id_onStart as jni.JMethodIDPtr).check(); + } + + static final _id_onResume = _class.instanceMethodId( + r'onResume', + r'()V', + ); + + static final _onResume = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onResume() + void onResume() { + _onResume(reference.pointer, _id_onResume as jni.JMethodIDPtr).check(); + } + + static final _id_onPostResume = _class.instanceMethodId( + r'onPostResume', + r'()V', + ); + + static final _onPostResume = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onPostResume() + void onPostResume() { + _onPostResume(reference.pointer, _id_onPostResume as jni.JMethodIDPtr) + .check(); + } + + static final _id_onPause = _class.instanceMethodId( + r'onPause', + r'()V', + ); + + static final _onPause = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onPause() + void onPause() { + _onPause(reference.pointer, _id_onPause as jni.JMethodIDPtr).check(); + } + + static final _id_onStop = _class.instanceMethodId( + r'onStop', + r'()V', + ); + + static final _onStop = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onStop() + void onStop() { + _onStop(reference.pointer, _id_onStop as jni.JMethodIDPtr).check(); + } + + static final _id_onSaveInstanceState = _class.instanceMethodId( + r'onSaveInstanceState', + r'(Landroid/os/Bundle;)V', + ); + + static final _onSaveInstanceState = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: protected void onSaveInstanceState(android.os.Bundle bundle) + void onSaveInstanceState( + Bundle bundle, + ) { + _onSaveInstanceState( + reference.pointer, + _id_onSaveInstanceState as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); + } + + static final _id_release1 = _class.instanceMethodId( + r'release', + r'()V', + ); + + static final _release1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void release() + void release1() { + _release1(reference.pointer, _id_release1 as jni.JMethodIDPtr).check(); + } + + static final _id_detachFromFlutterEngine = _class.instanceMethodId( + r'detachFromFlutterEngine', + r'()V', + ); + + static final _detachFromFlutterEngine = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void detachFromFlutterEngine() + void detachFromFlutterEngine() { + _detachFromFlutterEngine( + reference.pointer, _id_detachFromFlutterEngine as jni.JMethodIDPtr) + .check(); + } + + static final _id_onDestroy = _class.instanceMethodId( + r'onDestroy', + r'()V', + ); + + static final _onDestroy = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onDestroy() + void onDestroy() { + _onDestroy(reference.pointer, _id_onDestroy as jni.JMethodIDPtr).check(); + } + + static final _id_onActivityResult = _class.instanceMethodId( + r'onActivityResult', + r'(IILandroid/content/Intent;)V', + ); + + static final _onActivityResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, $Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, int, ffi.Pointer)>(); + + /// from: protected void onActivityResult(int i, int i1, android.content.Intent intent) + void onActivityResult( + int i, + int i1, + jni.JObject intent, + ) { + _onActivityResult( + reference.pointer, + _id_onActivityResult as jni.JMethodIDPtr, + i, + i1, + intent.reference.pointer) + .check(); + } + + static final _id_onNewIntent = _class.instanceMethodId( + r'onNewIntent', + r'(Landroid/content/Intent;)V', + ); + + static final _onNewIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: protected void onNewIntent(android.content.Intent intent) + void onNewIntent( + jni.JObject intent, + ) { + _onNewIntent(reference.pointer, _id_onNewIntent as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); + } + + static final _id_onBackPressed = _class.instanceMethodId( + r'onBackPressed', + r'()V', + ); + + static final _onBackPressed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onBackPressed() + void onBackPressed() { + _onBackPressed(reference.pointer, _id_onBackPressed as jni.JMethodIDPtr) + .check(); + } + + static final _id_startBackGesture = _class.instanceMethodId( + r'startBackGesture', + r'(Landroid/window/BackEvent;)V', + ); + + static final _startBackGesture = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void startBackGesture(android.window.BackEvent backEvent) + void startBackGesture( + jni.JObject backEvent, + ) { + _startBackGesture( + reference.pointer, + _id_startBackGesture as jni.JMethodIDPtr, + backEvent.reference.pointer) + .check(); + } + + static final _id_updateBackGestureProgress = _class.instanceMethodId( + r'updateBackGestureProgress', + r'(Landroid/window/BackEvent;)V', + ); + + static final _updateBackGestureProgress = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void updateBackGestureProgress(android.window.BackEvent backEvent) + void updateBackGestureProgress( + jni.JObject backEvent, + ) { + _updateBackGestureProgress( + reference.pointer, + _id_updateBackGestureProgress as jni.JMethodIDPtr, + backEvent.reference.pointer) + .check(); + } + + static final _id_commitBackGesture = _class.instanceMethodId( + r'commitBackGesture', + r'()V', + ); + + static final _commitBackGesture = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void commitBackGesture() + void commitBackGesture() { + _commitBackGesture( + reference.pointer, _id_commitBackGesture as jni.JMethodIDPtr) + .check(); + } + + static final _id_cancelBackGesture = _class.instanceMethodId( + r'cancelBackGesture', + r'()V', + ); + + static final _cancelBackGesture = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void cancelBackGesture() + void cancelBackGesture() { + _cancelBackGesture( + reference.pointer, _id_cancelBackGesture as jni.JMethodIDPtr) + .check(); + } + + static final _id_onRequestPermissionsResult = _class.instanceMethodId( + r'onRequestPermissionsResult', + r'(I[Ljava/lang/String;[I)V', + ); + + static final _onRequestPermissionsResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer, ffi.Pointer)>(); + + /// from: public void onRequestPermissionsResult(int i, java.lang.String[] strings, int[] is) + void onRequestPermissionsResult( + int i, + jni.JArray strings, + jni.JArray is0, + ) { + _onRequestPermissionsResult( + reference.pointer, + _id_onRequestPermissionsResult as jni.JMethodIDPtr, + i, + strings.reference.pointer, + is0.reference.pointer) + .check(); + } + + static final _id_onUserLeaveHint = _class.instanceMethodId( + r'onUserLeaveHint', + r'()V', + ); + + static final _onUserLeaveHint = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onUserLeaveHint() + void onUserLeaveHint() { + _onUserLeaveHint(reference.pointer, _id_onUserLeaveHint as jni.JMethodIDPtr) + .check(); + } + + static final _id_onWindowFocusChanged = _class.instanceMethodId( + r'onWindowFocusChanged', + r'(Z)V', + ); + + static final _onWindowFocusChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void onWindowFocusChanged(boolean z) + void onWindowFocusChanged( + bool z, + ) { + _onWindowFocusChanged(reference.pointer, + _id_onWindowFocusChanged as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_onTrimMemory = _class.instanceMethodId( + r'onTrimMemory', + r'(I)V', + ); + + static final _onTrimMemory = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void onTrimMemory(int i) + void onTrimMemory( + int i, + ) { + _onTrimMemory(reference.pointer, _id_onTrimMemory as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_getContext = _class.instanceMethodId( + r'getContext', + r'()Landroid/content/Context;', + ); + + static final _getContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.content.Context getContext() + /// The returned object must be released after use, by calling the [release] method. + Context getContext() { + return _getContext(reference.pointer, _id_getContext as jni.JMethodIDPtr) + .object(const $ContextType()); + } + + static final _id_getActivity = _class.instanceMethodId( + r'getActivity', + r'()Landroid/app/Activity;', + ); + + static final _getActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.app.Activity getActivity() + /// The returned object must be released after use, by calling the [release] method. + Activity getActivity() { + return _getActivity(reference.pointer, _id_getActivity as jni.JMethodIDPtr) + .object(const $ActivityType()); + } + + static final _id_getLifecycle = _class.instanceMethodId( + r'getLifecycle', + r'()Landroidx/lifecycle/Lifecycle;', + ); + + static final _getLifecycle = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public androidx.lifecycle.Lifecycle getLifecycle() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getLifecycle() { + return _getLifecycle( + reference.pointer, _id_getLifecycle as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getFlutterShellArgs = _class.instanceMethodId( + r'getFlutterShellArgs', + r'()Lio/flutter/embedding/engine/FlutterShellArgs;', + ); + + static final _getFlutterShellArgs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public io.flutter.embedding.engine.FlutterShellArgs getFlutterShellArgs() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getFlutterShellArgs() { + return _getFlutterShellArgs( + reference.pointer, _id_getFlutterShellArgs as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getCachedEngineId = _class.instanceMethodId( + r'getCachedEngineId', + r'()Ljava/lang/String;', + ); + + static final _getCachedEngineId = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getCachedEngineId() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getCachedEngineId() { + return _getCachedEngineId( + reference.pointer, _id_getCachedEngineId as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getCachedEngineGroupId = _class.instanceMethodId( + r'getCachedEngineGroupId', + r'()Ljava/lang/String;', + ); + + static final _getCachedEngineGroupId = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getCachedEngineGroupId() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getCachedEngineGroupId() { + return _getCachedEngineGroupId( + reference.pointer, _id_getCachedEngineGroupId as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_shouldDestroyEngineWithHost = _class.instanceMethodId( + r'shouldDestroyEngineWithHost', + r'()Z', + ); + + static final _shouldDestroyEngineWithHost = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean shouldDestroyEngineWithHost() + bool shouldDestroyEngineWithHost() { + return _shouldDestroyEngineWithHost(reference.pointer, + _id_shouldDestroyEngineWithHost as jni.JMethodIDPtr) + .boolean; + } + + static final _id_getDartEntrypointFunctionName = _class.instanceMethodId( + r'getDartEntrypointFunctionName', + r'()Ljava/lang/String;', + ); + + static final _getDartEntrypointFunctionName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getDartEntrypointFunctionName() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getDartEntrypointFunctionName() { + return _getDartEntrypointFunctionName(reference.pointer, + _id_getDartEntrypointFunctionName as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getDartEntrypointArgs = _class.instanceMethodId( + r'getDartEntrypointArgs', + r'()Ljava/util/List;', + ); + + static final _getDartEntrypointArgs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.util.List getDartEntrypointArgs() + /// The returned object must be released after use, by calling the [release] method. + jni.JList getDartEntrypointArgs() { + return _getDartEntrypointArgs( + reference.pointer, _id_getDartEntrypointArgs as jni.JMethodIDPtr) + .object(const jni.JListType(jni.JStringType())); + } + + static final _id_getDartEntrypointLibraryUri = _class.instanceMethodId( + r'getDartEntrypointLibraryUri', + r'()Ljava/lang/String;', + ); + + static final _getDartEntrypointLibraryUri = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getDartEntrypointLibraryUri() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getDartEntrypointLibraryUri() { + return _getDartEntrypointLibraryUri(reference.pointer, + _id_getDartEntrypointLibraryUri as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getInitialRoute = _class.instanceMethodId( + r'getInitialRoute', + r'()Ljava/lang/String;', + ); + + static final _getInitialRoute = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getInitialRoute() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getInitialRoute() { + return _getInitialRoute( + reference.pointer, _id_getInitialRoute as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getAppBundlePath = _class.instanceMethodId( + r'getAppBundlePath', + r'()Ljava/lang/String;', + ); + + static final _getAppBundlePath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getAppBundlePath() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getAppBundlePath() { + return _getAppBundlePath( + reference.pointer, _id_getAppBundlePath as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getRenderMode = _class.instanceMethodId( + r'getRenderMode', + r'()Lio/flutter/embedding/android/RenderMode;', + ); + + static final _getRenderMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public io.flutter.embedding.android.RenderMode getRenderMode() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getRenderMode() { + return _getRenderMode( + reference.pointer, _id_getRenderMode as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getTransparencyMode = _class.instanceMethodId( + r'getTransparencyMode', + r'()Lio/flutter/embedding/android/TransparencyMode;', + ); + + static final _getTransparencyMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public io.flutter.embedding.android.TransparencyMode getTransparencyMode() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getTransparencyMode() { + return _getTransparencyMode( + reference.pointer, _id_getTransparencyMode as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getBackgroundMode = _class.instanceMethodId( + r'getBackgroundMode', + r'()Lio/flutter/embedding/android/FlutterActivityLaunchConfigs$BackgroundMode;', + ); + + static final _getBackgroundMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected io.flutter.embedding.android.FlutterActivityLaunchConfigs$BackgroundMode getBackgroundMode() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getBackgroundMode() { + return _getBackgroundMode( + reference.pointer, _id_getBackgroundMode as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_provideFlutterEngine = _class.instanceMethodId( + r'provideFlutterEngine', + r'(Landroid/content/Context;)Lio/flutter/embedding/engine/FlutterEngine;', + ); + + static final _provideFlutterEngine = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public io.flutter.embedding.engine.FlutterEngine provideFlutterEngine(android.content.Context context) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject provideFlutterEngine( + Context context, + ) { + return _provideFlutterEngine( + reference.pointer, + _id_provideFlutterEngine as jni.JMethodIDPtr, + context.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getFlutterEngine = _class.instanceMethodId( + r'getFlutterEngine', + r'()Lio/flutter/embedding/engine/FlutterEngine;', + ); + + static final _getFlutterEngine = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected io.flutter.embedding.engine.FlutterEngine getFlutterEngine() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getFlutterEngine() { + return _getFlutterEngine( + reference.pointer, _id_getFlutterEngine as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getMetaData = _class.instanceMethodId( + r'getMetaData', + r'()Landroid/os/Bundle;', + ); + + static final _getMetaData = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected android.os.Bundle getMetaData() + /// The returned object must be released after use, by calling the [release] method. + Bundle getMetaData() { + return _getMetaData(reference.pointer, _id_getMetaData as jni.JMethodIDPtr) + .object(const $BundleType()); + } + + static final _id_providePlatformPlugin = _class.instanceMethodId( + r'providePlatformPlugin', + r'(Landroid/app/Activity;Lio/flutter/embedding/engine/FlutterEngine;)Lio/flutter/plugin/platform/PlatformPlugin;', + ); + + static final _providePlatformPlugin = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public io.flutter.plugin.platform.PlatformPlugin providePlatformPlugin(android.app.Activity activity, io.flutter.embedding.engine.FlutterEngine flutterEngine) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject providePlatformPlugin( + Activity activity, + jni.JObject flutterEngine, + ) { + return _providePlatformPlugin( + reference.pointer, + _id_providePlatformPlugin as jni.JMethodIDPtr, + activity.reference.pointer, + flutterEngine.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_configureFlutterEngine = _class.instanceMethodId( + r'configureFlutterEngine', + r'(Lio/flutter/embedding/engine/FlutterEngine;)V', + ); + + static final _configureFlutterEngine = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void configureFlutterEngine(io.flutter.embedding.engine.FlutterEngine flutterEngine) + void configureFlutterEngine( + jni.JObject flutterEngine, + ) { + _configureFlutterEngine( + reference.pointer, + _id_configureFlutterEngine as jni.JMethodIDPtr, + flutterEngine.reference.pointer) + .check(); + } + + static final _id_cleanUpFlutterEngine = _class.instanceMethodId( + r'cleanUpFlutterEngine', + r'(Lio/flutter/embedding/engine/FlutterEngine;)V', + ); + + static final _cleanUpFlutterEngine = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void cleanUpFlutterEngine(io.flutter.embedding.engine.FlutterEngine flutterEngine) + void cleanUpFlutterEngine( + jni.JObject flutterEngine, + ) { + _cleanUpFlutterEngine( + reference.pointer, + _id_cleanUpFlutterEngine as jni.JMethodIDPtr, + flutterEngine.reference.pointer) + .check(); + } + + static final _id_shouldAttachEngineToActivity = _class.instanceMethodId( + r'shouldAttachEngineToActivity', + r'()Z', + ); + + static final _shouldAttachEngineToActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean shouldAttachEngineToActivity() + bool shouldAttachEngineToActivity() { + return _shouldAttachEngineToActivity(reference.pointer, + _id_shouldAttachEngineToActivity as jni.JMethodIDPtr) + .boolean; + } + + static final _id_shouldHandleDeeplinking = _class.instanceMethodId( + r'shouldHandleDeeplinking', + r'()Z', + ); + + static final _shouldHandleDeeplinking = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean shouldHandleDeeplinking() + bool shouldHandleDeeplinking() { + return _shouldHandleDeeplinking( + reference.pointer, _id_shouldHandleDeeplinking as jni.JMethodIDPtr) + .boolean; + } + + static final _id_onFlutterSurfaceViewCreated = _class.instanceMethodId( + r'onFlutterSurfaceViewCreated', + r'(Lio/flutter/embedding/android/FlutterSurfaceView;)V', + ); + + static final _onFlutterSurfaceViewCreated = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onFlutterSurfaceViewCreated(io.flutter.embedding.android.FlutterSurfaceView flutterSurfaceView) + void onFlutterSurfaceViewCreated( + jni.JObject flutterSurfaceView, + ) { + _onFlutterSurfaceViewCreated( + reference.pointer, + _id_onFlutterSurfaceViewCreated as jni.JMethodIDPtr, + flutterSurfaceView.reference.pointer) + .check(); + } + + static final _id_onFlutterTextureViewCreated = _class.instanceMethodId( + r'onFlutterTextureViewCreated', + r'(Lio/flutter/embedding/android/FlutterTextureView;)V', + ); + + static final _onFlutterTextureViewCreated = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onFlutterTextureViewCreated(io.flutter.embedding.android.FlutterTextureView flutterTextureView) + void onFlutterTextureViewCreated( + jni.JObject flutterTextureView, + ) { + _onFlutterTextureViewCreated( + reference.pointer, + _id_onFlutterTextureViewCreated as jni.JMethodIDPtr, + flutterTextureView.reference.pointer) + .check(); + } + + static final _id_onFlutterUiDisplayed = _class.instanceMethodId( + r'onFlutterUiDisplayed', + r'()V', + ); + + static final _onFlutterUiDisplayed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onFlutterUiDisplayed() + void onFlutterUiDisplayed() { + _onFlutterUiDisplayed( + reference.pointer, _id_onFlutterUiDisplayed as jni.JMethodIDPtr) + .check(); + } + + static final _id_onFlutterUiNoLongerDisplayed = _class.instanceMethodId( + r'onFlutterUiNoLongerDisplayed', + r'()V', + ); + + static final _onFlutterUiNoLongerDisplayed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onFlutterUiNoLongerDisplayed() + void onFlutterUiNoLongerDisplayed() { + _onFlutterUiNoLongerDisplayed(reference.pointer, + _id_onFlutterUiNoLongerDisplayed as jni.JMethodIDPtr) + .check(); + } + + static final _id_shouldRestoreAndSaveState = _class.instanceMethodId( + r'shouldRestoreAndSaveState', + r'()Z', + ); + + static final _shouldRestoreAndSaveState = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean shouldRestoreAndSaveState() + bool shouldRestoreAndSaveState() { + return _shouldRestoreAndSaveState(reference.pointer, + _id_shouldRestoreAndSaveState as jni.JMethodIDPtr) + .boolean; + } + + static final _id_shouldDispatchAppLifecycleState = _class.instanceMethodId( + r'shouldDispatchAppLifecycleState', + r'()Z', + ); + + static final _shouldDispatchAppLifecycleState = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean shouldDispatchAppLifecycleState() + bool shouldDispatchAppLifecycleState() { + return _shouldDispatchAppLifecycleState(reference.pointer, + _id_shouldDispatchAppLifecycleState as jni.JMethodIDPtr) + .boolean; + } + + static final _id_attachToEngineAutomatically = _class.instanceMethodId( + r'attachToEngineAutomatically', + r'()Z', + ); + + static final _attachToEngineAutomatically = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean attachToEngineAutomatically() + bool attachToEngineAutomatically() { + return _attachToEngineAutomatically(reference.pointer, + _id_attachToEngineAutomatically as jni.JMethodIDPtr) + .boolean; + } + + static final _id_popSystemNavigator = _class.instanceMethodId( + r'popSystemNavigator', + r'()Z', + ); + + static final _popSystemNavigator = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean popSystemNavigator() + bool popSystemNavigator() { + return _popSystemNavigator( + reference.pointer, _id_popSystemNavigator as jni.JMethodIDPtr) + .boolean; + } + + static final _id_updateSystemUiOverlays = _class.instanceMethodId( + r'updateSystemUiOverlays', + r'()V', + ); + + static final _updateSystemUiOverlays = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void updateSystemUiOverlays() + void updateSystemUiOverlays() { + _updateSystemUiOverlays( + reference.pointer, _id_updateSystemUiOverlays as jni.JMethodIDPtr) + .check(); + } +} + +final class $FlutterActivityType extends jni.JObjType { + const $FlutterActivityType(); + + @override + String get signature => r'Lio/flutter/embedding/android/FlutterActivity;'; + + @override + FlutterActivity fromReference(jni.JReference reference) => + FlutterActivity.fromReference(reference); + + @override + jni.JObjType get superType => const $ActivityType(); + + @override + final superCount = 2; + + @override + int get hashCode => ($FlutterActivityType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($FlutterActivityType) && + other is $FlutterActivityType; + } +} + +/// from: java.lang.Runnable +class Runnable extends jni.JObject { + @override + late final jni.JObjType $type = type; + + Runnable.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r'java/lang/Runnable'); + + /// The type which includes information such as the signature of this class. + static const type = $RunnableType(); + static final _id_run = _class.instanceMethodId( + r'run', + r'()V', + ); + + static final _run = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract void run() + void run() { + _run(reference.pointer, _id_run as jni.JMethodIDPtr).check(); + } + + /// Maps a specific port to the implemented interface. + static final Map _$impls = {}; + ReceivePort? _$p; + + static jni.JObjectPtr _$invoke( + int port, + jni.JObjectPtr descriptor, + jni.JObjectPtr args, + ) { + return _$invokeMethod( + port, + $MethodInvocation.fromAddresses( + 0, + descriptor.address, + args.address, + ), + ); + } + + static final ffi.Pointer< + ffi.NativeFunction< + jni.JObjectPtr Function( + ffi.Uint64, jni.JObjectPtr, jni.JObjectPtr)>> + _$invokePointer = ffi.Pointer.fromFunction(_$invoke); + + static ffi.Pointer _$invokeMethod( + int $p, + $MethodInvocation $i, + ) { + try { + final $d = $i.methodDescriptor.toDartString(releaseOriginal: true); + final $a = $i.args; + if ($d == r'run()V') { + _$impls[$p]!.run(); + return jni.nullptr; + } + } catch (e) { + return ProtectedJniExtensions.newDartException(e); + } + return jni.nullptr; + } + + factory Runnable.implement( + $RunnableImpl $impl, + ) { + final $p = ReceivePort(); + final $x = Runnable.fromReference( + ProtectedJniExtensions.newPortProxy( + r'java.lang.Runnable', + $p, + _$invokePointer, + ), + ).._$p = $p; + final $a = $p.sendPort.nativePort; + _$impls[$a] = $impl; + $p.listen(($m) { + if ($m == null) { + _$impls.remove($p.sendPort.nativePort); + $p.close(); + return; + } + final $i = $MethodInvocation.fromMessage($m as List); + final $r = _$invokeMethod($p.sendPort.nativePort, $i); + ProtectedJniExtensions.returnResult($i.result, $r); + }); + return $x; + } +} + +abstract interface class $RunnableImpl { + factory $RunnableImpl({ + required void Function() run, + }) = _$RunnableImpl; + + void run(); +} + +class _$RunnableImpl implements $RunnableImpl { + _$RunnableImpl({ + required void Function() run, + }) : _run = run; + + final void Function() _run; + + void run() { + return _run(); + } +} + +final class $RunnableType extends jni.JObjType { + const $RunnableType(); + + @override + String get signature => r'Ljava/lang/Runnable;'; + + @override + Runnable fromReference(jni.JReference reference) => + Runnable.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($RunnableType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($RunnableType) && other is $RunnableType; + } +} + +/// from: java.lang.Exception +class Exception extends Throwable { + @override + late final jni.JObjType $type = type; + + Exception.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r'java/lang/Exception'); + + /// The type which includes information such as the signature of this class. + static const type = $ExceptionType(); + static final _id_new0 = _class.constructorId( + r'()V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void () + /// The returned object must be released after use, by calling the [release] method. + factory Exception() { + return Exception.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); + } + + static final _id_new1 = _class.constructorId( + r'(Ljava/lang/String;)V', + ); + + static final _new1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void (java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + factory Exception.new1( + jni.JString string, + ) { + return Exception.fromReference(_new1(_class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, string.reference.pointer) + .reference); + } + + static final _id_new2 = _class.constructorId( + r'(Ljava/lang/String;Ljava/lang/Throwable;)V', + ); + + static final _new2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void (java.lang.String string, java.lang.Throwable throwable) + /// The returned object must be released after use, by calling the [release] method. + factory Exception.new2( + jni.JString string, + Throwable throwable, + ) { + return Exception.fromReference(_new2( + _class.reference.pointer, + _id_new2 as jni.JMethodIDPtr, + string.reference.pointer, + throwable.reference.pointer) + .reference); + } + + static final _id_new3 = _class.constructorId( + r'(Ljava/lang/Throwable;)V', + ); + + static final _new3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void (java.lang.Throwable throwable) + /// The returned object must be released after use, by calling the [release] method. + factory Exception.new3( + Throwable throwable, + ) { + return Exception.fromReference(_new3(_class.reference.pointer, + _id_new3 as jni.JMethodIDPtr, throwable.reference.pointer) + .reference); + } + + static final _id_new4 = _class.constructorId( + r'(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V', + ); + + static final _new4 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + $Int32 + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int, int)>(); + + /// from: protected void (java.lang.String string, java.lang.Throwable throwable, boolean z, boolean z1) + /// The returned object must be released after use, by calling the [release] method. + factory Exception.new4( + jni.JString string, + Throwable throwable, + bool z, + bool z1, + ) { + return Exception.fromReference(_new4( + _class.reference.pointer, + _id_new4 as jni.JMethodIDPtr, + string.reference.pointer, + throwable.reference.pointer, + z ? 1 : 0, + z1 ? 1 : 0) + .reference); + } +} + +final class $ExceptionType extends jni.JObjType { + const $ExceptionType(); + + @override + String get signature => r'Ljava/lang/Exception;'; + + @override + Exception fromReference(jni.JReference reference) => + Exception.fromReference(reference); + + @override + jni.JObjType get superType => const $ThrowableType(); + + @override + final superCount = 2; + + @override + int get hashCode => ($ExceptionType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($ExceptionType) && other is $ExceptionType; + } +} + +/// from: java.lang.Throwable +class Throwable extends jni.JObject { + @override + late final jni.JObjType $type = type; + + Throwable.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r'java/lang/Throwable'); + + /// The type which includes information such as the signature of this class. + static const type = $ThrowableType(); + static final _id_new0 = _class.constructorId( + r'()V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void () + /// The returned object must be released after use, by calling the [release] method. + factory Throwable() { + return Throwable.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); + } + + static final _id_new1 = _class.constructorId( + r'(Ljava/lang/String;)V', + ); + + static final _new1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void (java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + factory Throwable.new1( + jni.JString string, + ) { + return Throwable.fromReference(_new1(_class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, string.reference.pointer) + .reference); + } + + static final _id_new2 = _class.constructorId( + r'(Ljava/lang/String;Ljava/lang/Throwable;)V', + ); + + static final _new2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void (java.lang.String string, java.lang.Throwable throwable) + /// The returned object must be released after use, by calling the [release] method. + factory Throwable.new2( + jni.JString string, + Throwable throwable, + ) { + return Throwable.fromReference(_new2( + _class.reference.pointer, + _id_new2 as jni.JMethodIDPtr, + string.reference.pointer, + throwable.reference.pointer) + .reference); + } + + static final _id_new3 = _class.constructorId( + r'(Ljava/lang/Throwable;)V', + ); + + static final _new3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void (java.lang.Throwable throwable) + /// The returned object must be released after use, by calling the [release] method. + factory Throwable.new3( + Throwable throwable, + ) { + return Throwable.fromReference(_new3(_class.reference.pointer, + _id_new3 as jni.JMethodIDPtr, throwable.reference.pointer) + .reference); + } + + static final _id_new4 = _class.constructorId( + r'(Ljava/lang/String;Ljava/lang/Throwable;ZZ)V', + ); + + static final _new4 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + $Int32 + )>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int, int)>(); + + /// from: protected void (java.lang.String string, java.lang.Throwable throwable, boolean z, boolean z1) + /// The returned object must be released after use, by calling the [release] method. + factory Throwable.new4( + jni.JString string, + Throwable throwable, + bool z, + bool z1, + ) { + return Throwable.fromReference(_new4( + _class.reference.pointer, + _id_new4 as jni.JMethodIDPtr, + string.reference.pointer, + throwable.reference.pointer, + z ? 1 : 0, + z1 ? 1 : 0) + .reference); + } + + static final _id_getMessage = _class.instanceMethodId( + r'getMessage', + r'()Ljava/lang/String;', + ); + + static final _getMessage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getMessage() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getMessage() { + return _getMessage(reference.pointer, _id_getMessage as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getLocalizedMessage = _class.instanceMethodId( + r'getLocalizedMessage', + r'()Ljava/lang/String;', + ); + + static final _getLocalizedMessage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getLocalizedMessage() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getLocalizedMessage() { + return _getLocalizedMessage( + reference.pointer, _id_getLocalizedMessage as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getCause = _class.instanceMethodId( + r'getCause', + r'()Ljava/lang/Throwable;', + ); + + static final _getCause = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.Throwable getCause() + /// The returned object must be released after use, by calling the [release] method. + Throwable getCause() { + return _getCause(reference.pointer, _id_getCause as jni.JMethodIDPtr) + .object(const $ThrowableType()); + } + + static final _id_initCause = _class.instanceMethodId( + r'initCause', + r'(Ljava/lang/Throwable;)Ljava/lang/Throwable;', + ); + + static final _initCause = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.lang.Throwable initCause(java.lang.Throwable throwable) + /// The returned object must be released after use, by calling the [release] method. + Throwable initCause( + Throwable throwable, + ) { + return _initCause(reference.pointer, _id_initCause as jni.JMethodIDPtr, + throwable.reference.pointer) + .object(const $ThrowableType()); + } + + static final _id_toString1 = _class.instanceMethodId( + r'toString', + r'()Ljava/lang/String;', + ); + + static final _toString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String toString() + /// The returned object must be released after use, by calling the [release] method. + jni.JString toString1() { + return _toString1(reference.pointer, _id_toString1 as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_printStackTrace = _class.instanceMethodId( + r'printStackTrace', + r'()V', + ); + + static final _printStackTrace = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void printStackTrace() + void printStackTrace() { + _printStackTrace(reference.pointer, _id_printStackTrace as jni.JMethodIDPtr) + .check(); + } + + static final _id_printStackTrace1 = _class.instanceMethodId( + r'printStackTrace', + r'(Ljava/io/PrintStream;)V', + ); + + static final _printStackTrace1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void printStackTrace(java.io.PrintStream printStream) + void printStackTrace1( + jni.JObject printStream, + ) { + _printStackTrace1( + reference.pointer, + _id_printStackTrace1 as jni.JMethodIDPtr, + printStream.reference.pointer) + .check(); + } + + static final _id_printStackTrace2 = _class.instanceMethodId( + r'printStackTrace', + r'(Ljava/io/PrintWriter;)V', + ); + + static final _printStackTrace2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void printStackTrace(java.io.PrintWriter printWriter) + void printStackTrace2( + jni.JObject printWriter, + ) { + _printStackTrace2( + reference.pointer, + _id_printStackTrace2 as jni.JMethodIDPtr, + printWriter.reference.pointer) + .check(); + } + + static final _id_fillInStackTrace = _class.instanceMethodId( + r'fillInStackTrace', + r'()Ljava/lang/Throwable;', + ); + + static final _fillInStackTrace = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.Throwable fillInStackTrace() + /// The returned object must be released after use, by calling the [release] method. + Throwable fillInStackTrace() { + return _fillInStackTrace( + reference.pointer, _id_fillInStackTrace as jni.JMethodIDPtr) + .object(const $ThrowableType()); + } + + static final _id_getStackTrace = _class.instanceMethodId( + r'getStackTrace', + r'()[Ljava/lang/StackTraceElement;', + ); + + static final _getStackTrace = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.StackTraceElement[] getStackTrace() + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getStackTrace() { + return _getStackTrace( + reference.pointer, _id_getStackTrace as jni.JMethodIDPtr) + .object(const jni.JArrayType(jni.JObjectType())); + } + + static final _id_setStackTrace = _class.instanceMethodId( + r'setStackTrace', + r'([Ljava/lang/StackTraceElement;)V', + ); + + static final _setStackTrace = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setStackTrace(java.lang.StackTraceElement[] stackTraceElements) + void setStackTrace( + jni.JArray stackTraceElements, + ) { + _setStackTrace(reference.pointer, _id_setStackTrace as jni.JMethodIDPtr, + stackTraceElements.reference.pointer) + .check(); + } + + static final _id_addSuppressed = _class.instanceMethodId( + r'addSuppressed', + r'(Ljava/lang/Throwable;)V', + ); + + static final _addSuppressed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public final void addSuppressed(java.lang.Throwable throwable) + void addSuppressed( + Throwable throwable, + ) { + _addSuppressed(reference.pointer, _id_addSuppressed as jni.JMethodIDPtr, + throwable.reference.pointer) + .check(); + } + + static final _id_getSuppressed = _class.instanceMethodId( + r'getSuppressed', + r'()[Ljava/lang/Throwable;', + ); + + static final _getSuppressed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final java.lang.Throwable[] getSuppressed() + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getSuppressed() { + return _getSuppressed( + reference.pointer, _id_getSuppressed as jni.JMethodIDPtr) + .object(const jni.JArrayType($ThrowableType())); + } +} + +final class $ThrowableType extends jni.JObjType { + const $ThrowableType(); + + @override + String get signature => r'Ljava/lang/Throwable;'; + + @override + Throwable fromReference(jni.JReference reference) => + Throwable.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($ThrowableType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($ThrowableType) && other is $ThrowableType; + } +} + +/// from: android.app.Activity$ScreenCaptureCallback +class Activity_ScreenCaptureCallback extends jni.JObject { + @override + late final jni.JObjType $type = type; + + Activity_ScreenCaptureCallback.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r'android/app/Activity$ScreenCaptureCallback'); + + /// The type which includes information such as the signature of this class. + static const type = $Activity_ScreenCaptureCallbackType(); + static final _id_onScreenCaptured = _class.instanceMethodId( + r'onScreenCaptured', + r'()V', + ); + + static final _onScreenCaptured = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract void onScreenCaptured() + void onScreenCaptured() { + _onScreenCaptured( + reference.pointer, _id_onScreenCaptured as jni.JMethodIDPtr) + .check(); + } + + /// Maps a specific port to the implemented interface. + static final Map _$impls = {}; + ReceivePort? _$p; + + static jni.JObjectPtr _$invoke( + int port, + jni.JObjectPtr descriptor, + jni.JObjectPtr args, + ) { + return _$invokeMethod( + port, + $MethodInvocation.fromAddresses( + 0, + descriptor.address, + args.address, + ), + ); + } + + static final ffi.Pointer< + ffi.NativeFunction< + jni.JObjectPtr Function( + ffi.Uint64, jni.JObjectPtr, jni.JObjectPtr)>> + _$invokePointer = ffi.Pointer.fromFunction(_$invoke); + + static ffi.Pointer _$invokeMethod( + int $p, + $MethodInvocation $i, + ) { + try { + final $d = $i.methodDescriptor.toDartString(releaseOriginal: true); + final $a = $i.args; + if ($d == r'onScreenCaptured()V') { + _$impls[$p]!.onScreenCaptured(); + return jni.nullptr; + } + } catch (e) { + return ProtectedJniExtensions.newDartException(e); + } + return jni.nullptr; + } + + factory Activity_ScreenCaptureCallback.implement( + $Activity_ScreenCaptureCallbackImpl $impl, + ) { + final $p = ReceivePort(); + final $x = Activity_ScreenCaptureCallback.fromReference( + ProtectedJniExtensions.newPortProxy( + r'android.app.Activity$ScreenCaptureCallback', + $p, + _$invokePointer, + ), + ).._$p = $p; + final $a = $p.sendPort.nativePort; + _$impls[$a] = $impl; + $p.listen(($m) { + if ($m == null) { + _$impls.remove($p.sendPort.nativePort); + $p.close(); + return; + } + final $i = $MethodInvocation.fromMessage($m as List); + final $r = _$invokeMethod($p.sendPort.nativePort, $i); + ProtectedJniExtensions.returnResult($i.result, $r); + }); + return $x; + } +} + +abstract interface class $Activity_ScreenCaptureCallbackImpl { + factory $Activity_ScreenCaptureCallbackImpl({ + required void Function() onScreenCaptured, + }) = _$Activity_ScreenCaptureCallbackImpl; + + void onScreenCaptured(); +} + +class _$Activity_ScreenCaptureCallbackImpl + implements $Activity_ScreenCaptureCallbackImpl { + _$Activity_ScreenCaptureCallbackImpl({ + required void Function() onScreenCaptured, + }) : _onScreenCaptured = onScreenCaptured; + + final void Function() _onScreenCaptured; + + void onScreenCaptured() { + return _onScreenCaptured(); + } +} + +final class $Activity_ScreenCaptureCallbackType + extends jni.JObjType { + const $Activity_ScreenCaptureCallbackType(); + + @override + String get signature => r'Landroid/app/Activity$ScreenCaptureCallback;'; + + @override + Activity_ScreenCaptureCallback fromReference(jni.JReference reference) => + Activity_ScreenCaptureCallback.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($Activity_ScreenCaptureCallbackType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($Activity_ScreenCaptureCallbackType) && + other is $Activity_ScreenCaptureCallbackType; + } +} + +/// from: android.app.Activity +class Activity extends jni.JObject { + @override + late final jni.JObjType $type = type; + + Activity.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r'android/app/Activity'); + + /// The type which includes information such as the signature of this class. + static const type = $ActivityType(); + + /// from: static public final int DEFAULT_KEYS_DIALER + static const DEFAULT_KEYS_DIALER = 1; + + /// from: static public final int DEFAULT_KEYS_DISABLE + static const DEFAULT_KEYS_DISABLE = 0; + + /// from: static public final int DEFAULT_KEYS_SEARCH_GLOBAL + static const DEFAULT_KEYS_SEARCH_GLOBAL = 4; + + /// from: static public final int DEFAULT_KEYS_SEARCH_LOCAL + static const DEFAULT_KEYS_SEARCH_LOCAL = 3; + + /// from: static public final int DEFAULT_KEYS_SHORTCUT + static const DEFAULT_KEYS_SHORTCUT = 2; + static final _id_FOCUSED_STATE_SET = _class.staticFieldId( + r'FOCUSED_STATE_SET', + r'[I', + ); + + /// from: static protected final int[] FOCUSED_STATE_SET + /// The returned object must be released after use, by calling the [release] method. + static jni.JArray get FOCUSED_STATE_SET => + _id_FOCUSED_STATE_SET.get(_class, const jni.JArrayType(jni.jintType())); + + /// from: static public final int FULLSCREEN_MODE_REQUEST_ENTER + static const FULLSCREEN_MODE_REQUEST_ENTER = 1; + + /// from: static public final int FULLSCREEN_MODE_REQUEST_EXIT + static const FULLSCREEN_MODE_REQUEST_EXIT = 0; + + /// from: static public final int OVERRIDE_TRANSITION_CLOSE + static const OVERRIDE_TRANSITION_CLOSE = 1; + + /// from: static public final int OVERRIDE_TRANSITION_OPEN + static const OVERRIDE_TRANSITION_OPEN = 0; + + /// from: static public final int RESULT_CANCELED + static const RESULT_CANCELED = 0; + + /// from: static public final int RESULT_FIRST_USER + static const RESULT_FIRST_USER = 1; + + /// from: static public final int RESULT_OK + static const RESULT_OK = -1; + static final _id_new0 = _class.constructorId( + r'()V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void () + /// The returned object must be released after use, by calling the [release] method. + factory Activity() { + return Activity.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); + } + + static final _id_getIntent = _class.instanceMethodId( + r'getIntent', + r'()Landroid/content/Intent;', + ); + + static final _getIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.content.Intent getIntent() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getIntent() { + return _getIntent(reference.pointer, _id_getIntent as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_setIntent = _class.instanceMethodId( + r'setIntent', + r'(Landroid/content/Intent;)V', + ); + + static final _setIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setIntent(android.content.Intent intent) + void setIntent( + jni.JObject intent, + ) { + _setIntent(reference.pointer, _id_setIntent as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); + } + + static final _id_setLocusContext = _class.instanceMethodId( + r'setLocusContext', + r'(Landroid/content/LocusId;Landroid/os/Bundle;)V', + ); + + static final _setLocusContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void setLocusContext(android.content.LocusId locusId, android.os.Bundle bundle) + void setLocusContext( + jni.JObject locusId, + Bundle bundle, + ) { + _setLocusContext(reference.pointer, _id_setLocusContext as jni.JMethodIDPtr, + locusId.reference.pointer, bundle.reference.pointer) + .check(); + } + + static final _id_getApplication = _class.instanceMethodId( + r'getApplication', + r'()Landroid/app/Application;', + ); + + static final _getApplication = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.app.Application getApplication() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getApplication() { + return _getApplication( + reference.pointer, _id_getApplication as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_isChild = _class.instanceMethodId( + r'isChild', + r'()Z', + ); + + static final _isChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final boolean isChild() + bool isChild() { + return _isChild(reference.pointer, _id_isChild as jni.JMethodIDPtr).boolean; + } + + static final _id_getParent = _class.instanceMethodId( + r'getParent', + r'()Landroid/app/Activity;', + ); + + static final _getParent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.app.Activity getParent() + /// The returned object must be released after use, by calling the [release] method. + Activity getParent() { + return _getParent(reference.pointer, _id_getParent as jni.JMethodIDPtr) + .object(const $ActivityType()); + } + + static final _id_getWindowManager = _class.instanceMethodId( + r'getWindowManager', + r'()Landroid/view/WindowManager;', + ); + + static final _getWindowManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.view.WindowManager getWindowManager() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getWindowManager() { + return _getWindowManager( + reference.pointer, _id_getWindowManager as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getWindow = _class.instanceMethodId( + r'getWindow', + r'()Landroid/view/Window;', + ); + + static final _getWindow = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.view.Window getWindow() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getWindow() { + return _getWindow(reference.pointer, _id_getWindow as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getLoaderManager = _class.instanceMethodId( + r'getLoaderManager', + r'()Landroid/app/LoaderManager;', + ); + + static final _getLoaderManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.app.LoaderManager getLoaderManager() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getLoaderManager() { + return _getLoaderManager( + reference.pointer, _id_getLoaderManager as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getCurrentFocus = _class.instanceMethodId( + r'getCurrentFocus', + r'()Landroid/view/View;', + ); + + static final _getCurrentFocus = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.view.View getCurrentFocus() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getCurrentFocus() { + return _getCurrentFocus( + reference.pointer, _id_getCurrentFocus as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_attachBaseContext = _class.instanceMethodId( + r'attachBaseContext', + r'(Landroid/content/Context;)V', + ); + + static final _attachBaseContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: protected void attachBaseContext(android.content.Context context) + void attachBaseContext( + Context context, + ) { + _attachBaseContext( + reference.pointer, + _id_attachBaseContext as jni.JMethodIDPtr, + context.reference.pointer) + .check(); + } + + static final _id_registerActivityLifecycleCallbacks = _class.instanceMethodId( + r'registerActivityLifecycleCallbacks', + r'(Landroid/app/Application$ActivityLifecycleCallbacks;)V', + ); + + static final _registerActivityLifecycleCallbacks = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer)>(); + + /// from: public void registerActivityLifecycleCallbacks(android.app.Application$ActivityLifecycleCallbacks activityLifecycleCallbacks) + void registerActivityLifecycleCallbacks( + jni.JObject activityLifecycleCallbacks, + ) { + _registerActivityLifecycleCallbacks( + reference.pointer, + _id_registerActivityLifecycleCallbacks as jni.JMethodIDPtr, + activityLifecycleCallbacks.reference.pointer) + .check(); + } + + static final _id_unregisterActivityLifecycleCallbacks = + _class.instanceMethodId( + r'unregisterActivityLifecycleCallbacks', + r'(Landroid/app/Application$ActivityLifecycleCallbacks;)V', + ); + + static final _unregisterActivityLifecycleCallbacks = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer)>(); + + /// from: public void unregisterActivityLifecycleCallbacks(android.app.Application$ActivityLifecycleCallbacks activityLifecycleCallbacks) + void unregisterActivityLifecycleCallbacks( + jni.JObject activityLifecycleCallbacks, + ) { + _unregisterActivityLifecycleCallbacks( + reference.pointer, + _id_unregisterActivityLifecycleCallbacks as jni.JMethodIDPtr, + activityLifecycleCallbacks.reference.pointer) + .check(); + } + + static final _id_registerComponentCallbacks = _class.instanceMethodId( + r'registerComponentCallbacks', + r'(Landroid/content/ComponentCallbacks;)V', + ); + + static final _registerComponentCallbacks = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void registerComponentCallbacks(android.content.ComponentCallbacks componentCallbacks) + void registerComponentCallbacks( + jni.JObject componentCallbacks, + ) { + _registerComponentCallbacks( + reference.pointer, + _id_registerComponentCallbacks as jni.JMethodIDPtr, + componentCallbacks.reference.pointer) + .check(); + } + + static final _id_unregisterComponentCallbacks = _class.instanceMethodId( + r'unregisterComponentCallbacks', + r'(Landroid/content/ComponentCallbacks;)V', + ); + + static final _unregisterComponentCallbacks = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void unregisterComponentCallbacks(android.content.ComponentCallbacks componentCallbacks) + void unregisterComponentCallbacks( + jni.JObject componentCallbacks, + ) { + _unregisterComponentCallbacks( + reference.pointer, + _id_unregisterComponentCallbacks as jni.JMethodIDPtr, + componentCallbacks.reference.pointer) + .check(); + } + + static final _id_onCreate = _class.instanceMethodId( + r'onCreate', + r'(Landroid/os/Bundle;)V', + ); + + static final _onCreate = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: protected void onCreate(android.os.Bundle bundle) + void onCreate( + Bundle bundle, + ) { + _onCreate(reference.pointer, _id_onCreate as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); + } + + static final _id_getSplashScreen = _class.instanceMethodId( + r'getSplashScreen', + r'()Landroid/window/SplashScreen;', + ); + + static final _getSplashScreen = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.window.SplashScreen getSplashScreen() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSplashScreen() { + return _getSplashScreen( + reference.pointer, _id_getSplashScreen as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_onCreate1 = _class.instanceMethodId( + r'onCreate', + r'(Landroid/os/Bundle;Landroid/os/PersistableBundle;)V', + ); + + static final _onCreate1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void onCreate(android.os.Bundle bundle, android.os.PersistableBundle persistableBundle) + void onCreate1( + Bundle bundle, + jni.JObject persistableBundle, + ) { + _onCreate1(reference.pointer, _id_onCreate1 as jni.JMethodIDPtr, + bundle.reference.pointer, persistableBundle.reference.pointer) + .check(); + } + + static final _id_onRestoreInstanceState = _class.instanceMethodId( + r'onRestoreInstanceState', + r'(Landroid/os/Bundle;)V', + ); + + static final _onRestoreInstanceState = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: protected void onRestoreInstanceState(android.os.Bundle bundle) + void onRestoreInstanceState( + Bundle bundle, + ) { + _onRestoreInstanceState( + reference.pointer, + _id_onRestoreInstanceState as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); + } + + static final _id_onRestoreInstanceState1 = _class.instanceMethodId( + r'onRestoreInstanceState', + r'(Landroid/os/Bundle;Landroid/os/PersistableBundle;)V', + ); + + static final _onRestoreInstanceState1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void onRestoreInstanceState(android.os.Bundle bundle, android.os.PersistableBundle persistableBundle) + void onRestoreInstanceState1( + Bundle bundle, + jni.JObject persistableBundle, + ) { + _onRestoreInstanceState1( + reference.pointer, + _id_onRestoreInstanceState1 as jni.JMethodIDPtr, + bundle.reference.pointer, + persistableBundle.reference.pointer) + .check(); + } + + static final _id_onPostCreate = _class.instanceMethodId( + r'onPostCreate', + r'(Landroid/os/Bundle;)V', + ); + + static final _onPostCreate = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: protected void onPostCreate(android.os.Bundle bundle) + void onPostCreate( + Bundle bundle, + ) { + _onPostCreate(reference.pointer, _id_onPostCreate as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); + } + + static final _id_onPostCreate1 = _class.instanceMethodId( + r'onPostCreate', + r'(Landroid/os/Bundle;Landroid/os/PersistableBundle;)V', + ); + + static final _onPostCreate1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void onPostCreate(android.os.Bundle bundle, android.os.PersistableBundle persistableBundle) + void onPostCreate1( + Bundle bundle, + jni.JObject persistableBundle, + ) { + _onPostCreate1(reference.pointer, _id_onPostCreate1 as jni.JMethodIDPtr, + bundle.reference.pointer, persistableBundle.reference.pointer) + .check(); + } + + static final _id_onStart = _class.instanceMethodId( + r'onStart', + r'()V', + ); + + static final _onStart = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onStart() + void onStart() { + _onStart(reference.pointer, _id_onStart as jni.JMethodIDPtr).check(); + } + + static final _id_onRestart = _class.instanceMethodId( + r'onRestart', + r'()V', + ); + + static final _onRestart = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onRestart() + void onRestart() { + _onRestart(reference.pointer, _id_onRestart as jni.JMethodIDPtr).check(); + } + + static final _id_onStateNotSaved = _class.instanceMethodId( + r'onStateNotSaved', + r'()V', + ); + + static final _onStateNotSaved = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onStateNotSaved() + void onStateNotSaved() { + _onStateNotSaved(reference.pointer, _id_onStateNotSaved as jni.JMethodIDPtr) + .check(); + } + + static final _id_onResume = _class.instanceMethodId( + r'onResume', + r'()V', + ); + + static final _onResume = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onResume() + void onResume() { + _onResume(reference.pointer, _id_onResume as jni.JMethodIDPtr).check(); + } + + static final _id_onPostResume = _class.instanceMethodId( + r'onPostResume', + r'()V', + ); + + static final _onPostResume = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onPostResume() + void onPostResume() { + _onPostResume(reference.pointer, _id_onPostResume as jni.JMethodIDPtr) + .check(); + } + + static final _id_onTopResumedActivityChanged = _class.instanceMethodId( + r'onTopResumedActivityChanged', + r'(Z)V', + ); + + static final _onTopResumedActivityChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void onTopResumedActivityChanged(boolean z) + void onTopResumedActivityChanged( + bool z, + ) { + _onTopResumedActivityChanged(reference.pointer, + _id_onTopResumedActivityChanged as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_isVoiceInteraction = _class.instanceMethodId( + r'isVoiceInteraction', + r'()Z', + ); + + static final _isVoiceInteraction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isVoiceInteraction() + bool isVoiceInteraction() { + return _isVoiceInteraction( + reference.pointer, _id_isVoiceInteraction as jni.JMethodIDPtr) + .boolean; + } + + static final _id_isVoiceInteractionRoot = _class.instanceMethodId( + r'isVoiceInteractionRoot', + r'()Z', + ); + + static final _isVoiceInteractionRoot = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isVoiceInteractionRoot() + bool isVoiceInteractionRoot() { + return _isVoiceInteractionRoot( + reference.pointer, _id_isVoiceInteractionRoot as jni.JMethodIDPtr) + .boolean; + } + + static final _id_getVoiceInteractor = _class.instanceMethodId( + r'getVoiceInteractor', + r'()Landroid/app/VoiceInteractor;', + ); + + static final _getVoiceInteractor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.app.VoiceInteractor getVoiceInteractor() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getVoiceInteractor() { + return _getVoiceInteractor( + reference.pointer, _id_getVoiceInteractor as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_isLocalVoiceInteractionSupported = _class.instanceMethodId( + r'isLocalVoiceInteractionSupported', + r'()Z', + ); + + static final _isLocalVoiceInteractionSupported = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isLocalVoiceInteractionSupported() + bool isLocalVoiceInteractionSupported() { + return _isLocalVoiceInteractionSupported(reference.pointer, + _id_isLocalVoiceInteractionSupported as jni.JMethodIDPtr) + .boolean; + } + + static final _id_startLocalVoiceInteraction = _class.instanceMethodId( + r'startLocalVoiceInteraction', + r'(Landroid/os/Bundle;)V', + ); + + static final _startLocalVoiceInteraction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void startLocalVoiceInteraction(android.os.Bundle bundle) + void startLocalVoiceInteraction( + Bundle bundle, + ) { + _startLocalVoiceInteraction( + reference.pointer, + _id_startLocalVoiceInteraction as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); + } + + static final _id_onLocalVoiceInteractionStarted = _class.instanceMethodId( + r'onLocalVoiceInteractionStarted', + r'()V', + ); + + static final _onLocalVoiceInteractionStarted = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onLocalVoiceInteractionStarted() + void onLocalVoiceInteractionStarted() { + _onLocalVoiceInteractionStarted(reference.pointer, + _id_onLocalVoiceInteractionStarted as jni.JMethodIDPtr) + .check(); + } + + static final _id_onLocalVoiceInteractionStopped = _class.instanceMethodId( + r'onLocalVoiceInteractionStopped', + r'()V', + ); + + static final _onLocalVoiceInteractionStopped = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onLocalVoiceInteractionStopped() + void onLocalVoiceInteractionStopped() { + _onLocalVoiceInteractionStopped(reference.pointer, + _id_onLocalVoiceInteractionStopped as jni.JMethodIDPtr) + .check(); + } + + static final _id_stopLocalVoiceInteraction = _class.instanceMethodId( + r'stopLocalVoiceInteraction', + r'()V', + ); + + static final _stopLocalVoiceInteraction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void stopLocalVoiceInteraction() + void stopLocalVoiceInteraction() { + _stopLocalVoiceInteraction(reference.pointer, + _id_stopLocalVoiceInteraction as jni.JMethodIDPtr) + .check(); + } + + static final _id_onNewIntent = _class.instanceMethodId( + r'onNewIntent', + r'(Landroid/content/Intent;)V', + ); + + static final _onNewIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: protected void onNewIntent(android.content.Intent intent) + void onNewIntent( + jni.JObject intent, + ) { + _onNewIntent(reference.pointer, _id_onNewIntent as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); + } + + static final _id_onSaveInstanceState = _class.instanceMethodId( + r'onSaveInstanceState', + r'(Landroid/os/Bundle;)V', + ); + + static final _onSaveInstanceState = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: protected void onSaveInstanceState(android.os.Bundle bundle) + void onSaveInstanceState( + Bundle bundle, + ) { + _onSaveInstanceState( + reference.pointer, + _id_onSaveInstanceState as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); + } + + static final _id_onSaveInstanceState1 = _class.instanceMethodId( + r'onSaveInstanceState', + r'(Landroid/os/Bundle;Landroid/os/PersistableBundle;)V', + ); + + static final _onSaveInstanceState1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void onSaveInstanceState(android.os.Bundle bundle, android.os.PersistableBundle persistableBundle) + void onSaveInstanceState1( + Bundle bundle, + jni.JObject persistableBundle, + ) { + _onSaveInstanceState1( + reference.pointer, + _id_onSaveInstanceState1 as jni.JMethodIDPtr, + bundle.reference.pointer, + persistableBundle.reference.pointer) + .check(); + } + + static final _id_onPause = _class.instanceMethodId( + r'onPause', + r'()V', + ); + + static final _onPause = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onPause() + void onPause() { + _onPause(reference.pointer, _id_onPause as jni.JMethodIDPtr).check(); + } + + static final _id_onUserLeaveHint = _class.instanceMethodId( + r'onUserLeaveHint', + r'()V', + ); + + static final _onUserLeaveHint = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onUserLeaveHint() + void onUserLeaveHint() { + _onUserLeaveHint(reference.pointer, _id_onUserLeaveHint as jni.JMethodIDPtr) + .check(); + } + + static final _id_onCreateThumbnail = _class.instanceMethodId( + r'onCreateThumbnail', + r'(Landroid/graphics/Bitmap;Landroid/graphics/Canvas;)Z', + ); + + static final _onCreateThumbnail = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public boolean onCreateThumbnail(android.graphics.Bitmap bitmap, android.graphics.Canvas canvas) + bool onCreateThumbnail( + jni.JObject bitmap, + jni.JObject canvas, + ) { + return _onCreateThumbnail( + reference.pointer, + _id_onCreateThumbnail as jni.JMethodIDPtr, + bitmap.reference.pointer, + canvas.reference.pointer) + .boolean; + } + + static final _id_onCreateDescription = _class.instanceMethodId( + r'onCreateDescription', + r'()Ljava/lang/CharSequence;', + ); + + static final _onCreateDescription = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.CharSequence onCreateDescription() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject onCreateDescription() { + return _onCreateDescription( + reference.pointer, _id_onCreateDescription as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_onProvideAssistData = _class.instanceMethodId( + r'onProvideAssistData', + r'(Landroid/os/Bundle;)V', + ); + + static final _onProvideAssistData = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onProvideAssistData(android.os.Bundle bundle) + void onProvideAssistData( + Bundle bundle, + ) { + _onProvideAssistData( + reference.pointer, + _id_onProvideAssistData as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); + } + + static final _id_onProvideAssistContent = _class.instanceMethodId( + r'onProvideAssistContent', + r'(Landroid/app/assist/AssistContent;)V', + ); + + static final _onProvideAssistContent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onProvideAssistContent(android.app.assist.AssistContent assistContent) + void onProvideAssistContent( + jni.JObject assistContent, + ) { + _onProvideAssistContent( + reference.pointer, + _id_onProvideAssistContent as jni.JMethodIDPtr, + assistContent.reference.pointer) + .check(); + } + + static final _id_onGetDirectActions = _class.instanceMethodId( + r'onGetDirectActions', + r'(Landroid/os/CancellationSignal;Ljava/util/function/Consumer;)V', + ); + + static final _onGetDirectActions = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void onGetDirectActions(android.os.CancellationSignal cancellationSignal, java.util.function.Consumer consumer) + void onGetDirectActions( + CancellationSignal cancellationSignal, + jni.JObject consumer, + ) { + _onGetDirectActions( + reference.pointer, + _id_onGetDirectActions as jni.JMethodIDPtr, + cancellationSignal.reference.pointer, + consumer.reference.pointer) + .check(); + } + + static final _id_onPerformDirectAction = _class.instanceMethodId( + r'onPerformDirectAction', + r'(Ljava/lang/String;Landroid/os/Bundle;Landroid/os/CancellationSignal;Ljava/util/function/Consumer;)V', + ); + + static final _onPerformDirectAction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public void onPerformDirectAction(java.lang.String string, android.os.Bundle bundle, android.os.CancellationSignal cancellationSignal, java.util.function.Consumer consumer) + void onPerformDirectAction( + jni.JString string, + Bundle bundle, + CancellationSignal cancellationSignal, + jni.JObject consumer, + ) { + _onPerformDirectAction( + reference.pointer, + _id_onPerformDirectAction as jni.JMethodIDPtr, + string.reference.pointer, + bundle.reference.pointer, + cancellationSignal.reference.pointer, + consumer.reference.pointer) + .check(); + } + + static final _id_requestShowKeyboardShortcuts = _class.instanceMethodId( + r'requestShowKeyboardShortcuts', + r'()V', + ); + + static final _requestShowKeyboardShortcuts = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final void requestShowKeyboardShortcuts() + void requestShowKeyboardShortcuts() { + _requestShowKeyboardShortcuts(reference.pointer, + _id_requestShowKeyboardShortcuts as jni.JMethodIDPtr) + .check(); + } + + static final _id_dismissKeyboardShortcutsHelper = _class.instanceMethodId( + r'dismissKeyboardShortcutsHelper', + r'()V', + ); + + static final _dismissKeyboardShortcutsHelper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final void dismissKeyboardShortcutsHelper() + void dismissKeyboardShortcutsHelper() { + _dismissKeyboardShortcutsHelper(reference.pointer, + _id_dismissKeyboardShortcutsHelper as jni.JMethodIDPtr) + .check(); + } + + static final _id_onProvideKeyboardShortcuts = _class.instanceMethodId( + r'onProvideKeyboardShortcuts', + r'(Ljava/util/List;Landroid/view/Menu;I)V', + ); + + static final _onProvideKeyboardShortcuts = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); + + /// from: public void onProvideKeyboardShortcuts(java.util.List list, android.view.Menu menu, int i) + void onProvideKeyboardShortcuts( + jni.JList list, + jni.JObject menu, + int i, + ) { + _onProvideKeyboardShortcuts( + reference.pointer, + _id_onProvideKeyboardShortcuts as jni.JMethodIDPtr, + list.reference.pointer, + menu.reference.pointer, + i) + .check(); + } + + static final _id_showAssist = _class.instanceMethodId( + r'showAssist', + r'(Landroid/os/Bundle;)Z', + ); + + static final _showAssist = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean showAssist(android.os.Bundle bundle) + bool showAssist( + Bundle bundle, + ) { + return _showAssist(reference.pointer, _id_showAssist as jni.JMethodIDPtr, + bundle.reference.pointer) + .boolean; + } + + static final _id_onStop = _class.instanceMethodId( + r'onStop', + r'()V', + ); + + static final _onStop = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onStop() + void onStop() { + _onStop(reference.pointer, _id_onStop as jni.JMethodIDPtr).check(); + } + + static final _id_onDestroy = _class.instanceMethodId( + r'onDestroy', + r'()V', + ); + + static final _onDestroy = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: protected void onDestroy() + void onDestroy() { + _onDestroy(reference.pointer, _id_onDestroy as jni.JMethodIDPtr).check(); + } + + static final _id_reportFullyDrawn = _class.instanceMethodId( + r'reportFullyDrawn', + r'()V', + ); + + static final _reportFullyDrawn = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void reportFullyDrawn() + void reportFullyDrawn() { + _reportFullyDrawn( + reference.pointer, _id_reportFullyDrawn as jni.JMethodIDPtr) + .check(); + } + + static final _id_onMultiWindowModeChanged = _class.instanceMethodId( + r'onMultiWindowModeChanged', + r'(ZLandroid/content/res/Configuration;)V', + ); + + static final _onMultiWindowModeChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: public void onMultiWindowModeChanged(boolean z, android.content.res.Configuration configuration) + void onMultiWindowModeChanged( + bool z, + jni.JObject configuration, + ) { + _onMultiWindowModeChanged( + reference.pointer, + _id_onMultiWindowModeChanged as jni.JMethodIDPtr, + z ? 1 : 0, + configuration.reference.pointer) + .check(); + } + + static final _id_onMultiWindowModeChanged1 = _class.instanceMethodId( + r'onMultiWindowModeChanged', + r'(Z)V', + ); + + static final _onMultiWindowModeChanged1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void onMultiWindowModeChanged(boolean z) + void onMultiWindowModeChanged1( + bool z, + ) { + _onMultiWindowModeChanged1(reference.pointer, + _id_onMultiWindowModeChanged1 as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_isInMultiWindowMode = _class.instanceMethodId( + r'isInMultiWindowMode', + r'()Z', + ); + + static final _isInMultiWindowMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isInMultiWindowMode() + bool isInMultiWindowMode() { + return _isInMultiWindowMode( + reference.pointer, _id_isInMultiWindowMode as jni.JMethodIDPtr) + .boolean; + } + + static final _id_onPictureInPictureModeChanged = _class.instanceMethodId( + r'onPictureInPictureModeChanged', + r'(ZLandroid/content/res/Configuration;)V', + ); + + static final _onPictureInPictureModeChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: public void onPictureInPictureModeChanged(boolean z, android.content.res.Configuration configuration) + void onPictureInPictureModeChanged( + bool z, + jni.JObject configuration, + ) { + _onPictureInPictureModeChanged( + reference.pointer, + _id_onPictureInPictureModeChanged as jni.JMethodIDPtr, + z ? 1 : 0, + configuration.reference.pointer) + .check(); + } + + static final _id_onPictureInPictureUiStateChanged = _class.instanceMethodId( + r'onPictureInPictureUiStateChanged', + r'(Landroid/app/PictureInPictureUiState;)V', + ); + + static final _onPictureInPictureUiStateChanged = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer)>(); + + /// from: public void onPictureInPictureUiStateChanged(android.app.PictureInPictureUiState pictureInPictureUiState) + void onPictureInPictureUiStateChanged( + jni.JObject pictureInPictureUiState, + ) { + _onPictureInPictureUiStateChanged( + reference.pointer, + _id_onPictureInPictureUiStateChanged as jni.JMethodIDPtr, + pictureInPictureUiState.reference.pointer) + .check(); + } + + static final _id_onPictureInPictureModeChanged1 = _class.instanceMethodId( + r'onPictureInPictureModeChanged', + r'(Z)V', + ); + + static final _onPictureInPictureModeChanged1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void onPictureInPictureModeChanged(boolean z) + void onPictureInPictureModeChanged1( + bool z, + ) { + _onPictureInPictureModeChanged1(reference.pointer, + _id_onPictureInPictureModeChanged1 as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_isInPictureInPictureMode = _class.instanceMethodId( + r'isInPictureInPictureMode', + r'()Z', + ); + + static final _isInPictureInPictureMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isInPictureInPictureMode() + bool isInPictureInPictureMode() { + return _isInPictureInPictureMode( + reference.pointer, _id_isInPictureInPictureMode as jni.JMethodIDPtr) + .boolean; + } + + static final _id_enterPictureInPictureMode = _class.instanceMethodId( + r'enterPictureInPictureMode', + r'()V', + ); + + static final _enterPictureInPictureMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void enterPictureInPictureMode() + void enterPictureInPictureMode() { + _enterPictureInPictureMode(reference.pointer, + _id_enterPictureInPictureMode as jni.JMethodIDPtr) + .check(); + } + + static final _id_enterPictureInPictureMode1 = _class.instanceMethodId( + r'enterPictureInPictureMode', + r'(Landroid/app/PictureInPictureParams;)Z', + ); + + static final _enterPictureInPictureMode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean enterPictureInPictureMode(android.app.PictureInPictureParams pictureInPictureParams) + bool enterPictureInPictureMode1( + jni.JObject pictureInPictureParams, + ) { + return _enterPictureInPictureMode1( + reference.pointer, + _id_enterPictureInPictureMode1 as jni.JMethodIDPtr, + pictureInPictureParams.reference.pointer) + .boolean; + } + + static final _id_setPictureInPictureParams = _class.instanceMethodId( + r'setPictureInPictureParams', + r'(Landroid/app/PictureInPictureParams;)V', + ); + + static final _setPictureInPictureParams = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setPictureInPictureParams(android.app.PictureInPictureParams pictureInPictureParams) + void setPictureInPictureParams( + jni.JObject pictureInPictureParams, + ) { + _setPictureInPictureParams( + reference.pointer, + _id_setPictureInPictureParams as jni.JMethodIDPtr, + pictureInPictureParams.reference.pointer) + .check(); + } + + static final _id_getMaxNumPictureInPictureActions = _class.instanceMethodId( + r'getMaxNumPictureInPictureActions', + r'()I', + ); + + static final _getMaxNumPictureInPictureActions = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int getMaxNumPictureInPictureActions() + int getMaxNumPictureInPictureActions() { + return _getMaxNumPictureInPictureActions(reference.pointer, + _id_getMaxNumPictureInPictureActions as jni.JMethodIDPtr) + .integer; + } + + static final _id_onPictureInPictureRequested = _class.instanceMethodId( + r'onPictureInPictureRequested', + r'()Z', + ); + + static final _onPictureInPictureRequested = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean onPictureInPictureRequested() + bool onPictureInPictureRequested() { + return _onPictureInPictureRequested(reference.pointer, + _id_onPictureInPictureRequested as jni.JMethodIDPtr) + .boolean; + } + + static final _id_requestFullscreenMode = _class.instanceMethodId( + r'requestFullscreenMode', + r'(ILandroid/os/OutcomeReceiver;)V', + ); + + static final _requestFullscreenMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: public void requestFullscreenMode(int i, android.os.OutcomeReceiver outcomeReceiver) + void requestFullscreenMode( + int i, + jni.JObject outcomeReceiver, + ) { + _requestFullscreenMode( + reference.pointer, + _id_requestFullscreenMode as jni.JMethodIDPtr, + i, + outcomeReceiver.reference.pointer) + .check(); + } + + static final _id_setShouldDockBigOverlays = _class.instanceMethodId( + r'setShouldDockBigOverlays', + r'(Z)V', + ); + + static final _setShouldDockBigOverlays = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setShouldDockBigOverlays(boolean z) + void setShouldDockBigOverlays( + bool z, + ) { + _setShouldDockBigOverlays(reference.pointer, + _id_setShouldDockBigOverlays as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_shouldDockBigOverlays = _class.instanceMethodId( + r'shouldDockBigOverlays', + r'()Z', + ); + + static final _shouldDockBigOverlays = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean shouldDockBigOverlays() + bool shouldDockBigOverlays() { + return _shouldDockBigOverlays( + reference.pointer, _id_shouldDockBigOverlays as jni.JMethodIDPtr) + .boolean; + } + + static final _id_onConfigurationChanged = _class.instanceMethodId( + r'onConfigurationChanged', + r'(Landroid/content/res/Configuration;)V', + ); + + static final _onConfigurationChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onConfigurationChanged(android.content.res.Configuration configuration) + void onConfigurationChanged( + jni.JObject configuration, + ) { + _onConfigurationChanged( + reference.pointer, + _id_onConfigurationChanged as jni.JMethodIDPtr, + configuration.reference.pointer) + .check(); + } + + static final _id_getChangingConfigurations = _class.instanceMethodId( + r'getChangingConfigurations', + r'()I', + ); + + static final _getChangingConfigurations = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int getChangingConfigurations() + int getChangingConfigurations() { + return _getChangingConfigurations(reference.pointer, + _id_getChangingConfigurations as jni.JMethodIDPtr) + .integer; + } + + static final _id_getLastNonConfigurationInstance = _class.instanceMethodId( + r'getLastNonConfigurationInstance', + r'()Ljava/lang/Object;', + ); + + static final _getLastNonConfigurationInstance = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.Object getLastNonConfigurationInstance() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getLastNonConfigurationInstance() { + return _getLastNonConfigurationInstance(reference.pointer, + _id_getLastNonConfigurationInstance as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_onRetainNonConfigurationInstance = _class.instanceMethodId( + r'onRetainNonConfigurationInstance', + r'()Ljava/lang/Object;', + ); + + static final _onRetainNonConfigurationInstance = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.Object onRetainNonConfigurationInstance() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject onRetainNonConfigurationInstance() { + return _onRetainNonConfigurationInstance(reference.pointer, + _id_onRetainNonConfigurationInstance as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_onLowMemory = _class.instanceMethodId( + r'onLowMemory', + r'()V', + ); + + static final _onLowMemory = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onLowMemory() + void onLowMemory() { + _onLowMemory(reference.pointer, _id_onLowMemory as jni.JMethodIDPtr) + .check(); + } + + static final _id_onTrimMemory = _class.instanceMethodId( + r'onTrimMemory', + r'(I)V', + ); + + static final _onTrimMemory = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void onTrimMemory(int i) + void onTrimMemory( + int i, + ) { + _onTrimMemory(reference.pointer, _id_onTrimMemory as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_getFragmentManager = _class.instanceMethodId( + r'getFragmentManager', + r'()Landroid/app/FragmentManager;', + ); + + static final _getFragmentManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.app.FragmentManager getFragmentManager() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getFragmentManager() { + return _getFragmentManager( + reference.pointer, _id_getFragmentManager as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_onAttachFragment = _class.instanceMethodId( + r'onAttachFragment', + r'(Landroid/app/Fragment;)V', + ); + + static final _onAttachFragment = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onAttachFragment(android.app.Fragment fragment) + void onAttachFragment( + jni.JObject fragment, + ) { + _onAttachFragment( + reference.pointer, + _id_onAttachFragment as jni.JMethodIDPtr, + fragment.reference.pointer) + .check(); + } + + static final _id_managedQuery = _class.instanceMethodId( + r'managedQuery', + r'(Landroid/net/Uri;[Ljava/lang/String;Ljava/lang/String;[Ljava/lang/String;Ljava/lang/String;)Landroid/database/Cursor;', + ); + + static final _managedQuery = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public final android.database.Cursor managedQuery(android.net.Uri uri, java.lang.String[] strings, java.lang.String string, java.lang.String[] strings1, java.lang.String string1) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject managedQuery( + Uri uri, + jni.JArray strings, + jni.JString string, + jni.JArray strings1, + jni.JString string1, + ) { + return _managedQuery( + reference.pointer, + _id_managedQuery as jni.JMethodIDPtr, + uri.reference.pointer, + strings.reference.pointer, + string.reference.pointer, + strings1.reference.pointer, + string1.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_startManagingCursor = _class.instanceMethodId( + r'startManagingCursor', + r'(Landroid/database/Cursor;)V', + ); + + static final _startManagingCursor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void startManagingCursor(android.database.Cursor cursor) + void startManagingCursor( + jni.JObject cursor, + ) { + _startManagingCursor( + reference.pointer, + _id_startManagingCursor as jni.JMethodIDPtr, + cursor.reference.pointer) + .check(); + } + + static final _id_stopManagingCursor = _class.instanceMethodId( + r'stopManagingCursor', + r'(Landroid/database/Cursor;)V', + ); + + static final _stopManagingCursor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void stopManagingCursor(android.database.Cursor cursor) + void stopManagingCursor( + jni.JObject cursor, + ) { + _stopManagingCursor( + reference.pointer, + _id_stopManagingCursor as jni.JMethodIDPtr, + cursor.reference.pointer) + .check(); + } + + static final _id_findViewById = _class.instanceMethodId( + r'findViewById', + r'(I)Landroid/view/View;', + ); + + static final _findViewById = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public T findViewById(int i) + /// The returned object must be released after use, by calling the [release] method. + $T findViewById<$T extends jni.JObject>( + int i, { + required jni.JObjType<$T> T, + }) { + return _findViewById( + reference.pointer, _id_findViewById as jni.JMethodIDPtr, i) + .object(T); + } + + static final _id_requireViewById = _class.instanceMethodId( + r'requireViewById', + r'(I)Landroid/view/View;', + ); + + static final _requireViewById = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final T requireViewById(int i) + /// The returned object must be released after use, by calling the [release] method. + $T requireViewById<$T extends jni.JObject>( + int i, { + required jni.JObjType<$T> T, + }) { + return _requireViewById( + reference.pointer, _id_requireViewById as jni.JMethodIDPtr, i) + .object(T); + } + + static final _id_getActionBar = _class.instanceMethodId( + r'getActionBar', + r'()Landroid/app/ActionBar;', + ); + + static final _getActionBar = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.app.ActionBar getActionBar() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getActionBar() { + return _getActionBar( + reference.pointer, _id_getActionBar as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_setActionBar = _class.instanceMethodId( + r'setActionBar', + r'(Landroid/widget/Toolbar;)V', + ); + + static final _setActionBar = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setActionBar(android.widget.Toolbar toolbar) + void setActionBar( + jni.JObject toolbar, + ) { + _setActionBar(reference.pointer, _id_setActionBar as jni.JMethodIDPtr, + toolbar.reference.pointer) + .check(); + } + + static final _id_setContentView = _class.instanceMethodId( + r'setContentView', + r'(I)V', + ); + + static final _setContentView = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setContentView(int i) + void setContentView( + int i, + ) { + _setContentView( + reference.pointer, _id_setContentView as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_setContentView1 = _class.instanceMethodId( + r'setContentView', + r'(Landroid/view/View;)V', + ); + + static final _setContentView1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setContentView(android.view.View view) + void setContentView1( + jni.JObject view, + ) { + _setContentView1(reference.pointer, _id_setContentView1 as jni.JMethodIDPtr, + view.reference.pointer) + .check(); + } + + static final _id_setContentView2 = _class.instanceMethodId( + r'setContentView', + r'(Landroid/view/View;Landroid/view/ViewGroup$LayoutParams;)V', + ); + + static final _setContentView2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void setContentView(android.view.View view, android.view.ViewGroup$LayoutParams layoutParams) + void setContentView2( + jni.JObject view, + jni.JObject layoutParams, + ) { + _setContentView2(reference.pointer, _id_setContentView2 as jni.JMethodIDPtr, + view.reference.pointer, layoutParams.reference.pointer) + .check(); + } + + static final _id_addContentView = _class.instanceMethodId( + r'addContentView', + r'(Landroid/view/View;Landroid/view/ViewGroup$LayoutParams;)V', + ); + + static final _addContentView = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void addContentView(android.view.View view, android.view.ViewGroup$LayoutParams layoutParams) + void addContentView( + jni.JObject view, + jni.JObject layoutParams, + ) { + _addContentView(reference.pointer, _id_addContentView as jni.JMethodIDPtr, + view.reference.pointer, layoutParams.reference.pointer) + .check(); + } + + static final _id_getContentTransitionManager = _class.instanceMethodId( + r'getContentTransitionManager', + r'()Landroid/transition/TransitionManager;', + ); + + static final _getContentTransitionManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.transition.TransitionManager getContentTransitionManager() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getContentTransitionManager() { + return _getContentTransitionManager(reference.pointer, + _id_getContentTransitionManager as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_setContentTransitionManager = _class.instanceMethodId( + r'setContentTransitionManager', + r'(Landroid/transition/TransitionManager;)V', + ); + + static final _setContentTransitionManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setContentTransitionManager(android.transition.TransitionManager transitionManager) + void setContentTransitionManager( + jni.JObject transitionManager, + ) { + _setContentTransitionManager( + reference.pointer, + _id_setContentTransitionManager as jni.JMethodIDPtr, + transitionManager.reference.pointer) + .check(); + } + + static final _id_getContentScene = _class.instanceMethodId( + r'getContentScene', + r'()Landroid/transition/Scene;', + ); + + static final _getContentScene = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.transition.Scene getContentScene() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getContentScene() { + return _getContentScene( + reference.pointer, _id_getContentScene as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_setFinishOnTouchOutside = _class.instanceMethodId( + r'setFinishOnTouchOutside', + r'(Z)V', + ); + + static final _setFinishOnTouchOutside = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setFinishOnTouchOutside(boolean z) + void setFinishOnTouchOutside( + bool z, + ) { + _setFinishOnTouchOutside(reference.pointer, + _id_setFinishOnTouchOutside as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_setDefaultKeyMode = _class.instanceMethodId( + r'setDefaultKeyMode', + r'(I)V', + ); + + static final _setDefaultKeyMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void setDefaultKeyMode(int i) + void setDefaultKeyMode( + int i, + ) { + _setDefaultKeyMode( + reference.pointer, _id_setDefaultKeyMode as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_onKeyDown = _class.instanceMethodId( + r'onKeyDown', + r'(ILandroid/view/KeyEvent;)Z', + ); + + static final _onKeyDown = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public boolean onKeyDown(int i, android.view.KeyEvent keyEvent) + bool onKeyDown( + int i, + jni.JObject keyEvent, + ) { + return _onKeyDown(reference.pointer, _id_onKeyDown as jni.JMethodIDPtr, i, + keyEvent.reference.pointer) + .boolean; + } + + static final _id_onKeyLongPress = _class.instanceMethodId( + r'onKeyLongPress', + r'(ILandroid/view/KeyEvent;)Z', + ); + + static final _onKeyLongPress = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public boolean onKeyLongPress(int i, android.view.KeyEvent keyEvent) + bool onKeyLongPress( + int i, + jni.JObject keyEvent, + ) { + return _onKeyLongPress( + reference.pointer, + _id_onKeyLongPress as jni.JMethodIDPtr, + i, + keyEvent.reference.pointer) + .boolean; + } + + static final _id_onKeyUp = _class.instanceMethodId( + r'onKeyUp', + r'(ILandroid/view/KeyEvent;)Z', + ); + + static final _onKeyUp = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public boolean onKeyUp(int i, android.view.KeyEvent keyEvent) + bool onKeyUp( + int i, + jni.JObject keyEvent, + ) { + return _onKeyUp(reference.pointer, _id_onKeyUp as jni.JMethodIDPtr, i, + keyEvent.reference.pointer) + .boolean; + } + + static final _id_onKeyMultiple = _class.instanceMethodId( + r'onKeyMultiple', + r'(IILandroid/view/KeyEvent;)Z', + ); + + static final _onKeyMultiple = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, $Int32, ffi.Pointer)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + int, ffi.Pointer)>(); + + /// from: public boolean onKeyMultiple(int i, int i1, android.view.KeyEvent keyEvent) + bool onKeyMultiple( + int i, + int i1, + jni.JObject keyEvent, + ) { + return _onKeyMultiple( + reference.pointer, + _id_onKeyMultiple as jni.JMethodIDPtr, + i, + i1, + keyEvent.reference.pointer) + .boolean; + } + + static final _id_onBackPressed = _class.instanceMethodId( + r'onBackPressed', + r'()V', + ); + + static final _onBackPressed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onBackPressed() + void onBackPressed() { + _onBackPressed(reference.pointer, _id_onBackPressed as jni.JMethodIDPtr) + .check(); + } + + static final _id_onKeyShortcut = _class.instanceMethodId( + r'onKeyShortcut', + r'(ILandroid/view/KeyEvent;)Z', + ); + + static final _onKeyShortcut = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public boolean onKeyShortcut(int i, android.view.KeyEvent keyEvent) + bool onKeyShortcut( + int i, + jni.JObject keyEvent, + ) { + return _onKeyShortcut( + reference.pointer, + _id_onKeyShortcut as jni.JMethodIDPtr, + i, + keyEvent.reference.pointer) + .boolean; + } + + static final _id_onTouchEvent = _class.instanceMethodId( + r'onTouchEvent', + r'(Landroid/view/MotionEvent;)Z', + ); + + static final _onTouchEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean onTouchEvent(android.view.MotionEvent motionEvent) + bool onTouchEvent( + jni.JObject motionEvent, + ) { + return _onTouchEvent(reference.pointer, + _id_onTouchEvent as jni.JMethodIDPtr, motionEvent.reference.pointer) + .boolean; + } + + static final _id_onTrackballEvent = _class.instanceMethodId( + r'onTrackballEvent', + r'(Landroid/view/MotionEvent;)Z', + ); + + static final _onTrackballEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean onTrackballEvent(android.view.MotionEvent motionEvent) + bool onTrackballEvent( + jni.JObject motionEvent, + ) { + return _onTrackballEvent( + reference.pointer, + _id_onTrackballEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) + .boolean; + } + + static final _id_onGenericMotionEvent = _class.instanceMethodId( + r'onGenericMotionEvent', + r'(Landroid/view/MotionEvent;)Z', + ); + + static final _onGenericMotionEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean onGenericMotionEvent(android.view.MotionEvent motionEvent) + bool onGenericMotionEvent( + jni.JObject motionEvent, + ) { + return _onGenericMotionEvent( + reference.pointer, + _id_onGenericMotionEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) + .boolean; + } + + static final _id_onUserInteraction = _class.instanceMethodId( + r'onUserInteraction', + r'()V', + ); + + static final _onUserInteraction = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onUserInteraction() + void onUserInteraction() { + _onUserInteraction( + reference.pointer, _id_onUserInteraction as jni.JMethodIDPtr) + .check(); + } + + static final _id_onWindowAttributesChanged = _class.instanceMethodId( + r'onWindowAttributesChanged', + r'(Landroid/view/WindowManager$LayoutParams;)V', + ); + + static final _onWindowAttributesChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onWindowAttributesChanged(android.view.WindowManager$LayoutParams layoutParams) + void onWindowAttributesChanged( + jni.JObject layoutParams, + ) { + _onWindowAttributesChanged( + reference.pointer, + _id_onWindowAttributesChanged as jni.JMethodIDPtr, + layoutParams.reference.pointer) + .check(); + } + + static final _id_onContentChanged = _class.instanceMethodId( + r'onContentChanged', + r'()V', + ); + + static final _onContentChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onContentChanged() + void onContentChanged() { + _onContentChanged( + reference.pointer, _id_onContentChanged as jni.JMethodIDPtr) + .check(); + } + + static final _id_onWindowFocusChanged = _class.instanceMethodId( + r'onWindowFocusChanged', + r'(Z)V', + ); + + static final _onWindowFocusChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void onWindowFocusChanged(boolean z) + void onWindowFocusChanged( + bool z, + ) { + _onWindowFocusChanged(reference.pointer, + _id_onWindowFocusChanged as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_onAttachedToWindow = _class.instanceMethodId( + r'onAttachedToWindow', + r'()V', + ); + + static final _onAttachedToWindow = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onAttachedToWindow() + void onAttachedToWindow() { + _onAttachedToWindow( + reference.pointer, _id_onAttachedToWindow as jni.JMethodIDPtr) + .check(); + } + + static final _id_onDetachedFromWindow = _class.instanceMethodId( + r'onDetachedFromWindow', + r'()V', + ); + + static final _onDetachedFromWindow = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onDetachedFromWindow() + void onDetachedFromWindow() { + _onDetachedFromWindow( + reference.pointer, _id_onDetachedFromWindow as jni.JMethodIDPtr) + .check(); + } + + static final _id_hasWindowFocus = _class.instanceMethodId( + r'hasWindowFocus', + r'()Z', + ); + + static final _hasWindowFocus = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean hasWindowFocus() + bool hasWindowFocus() { + return _hasWindowFocus( + reference.pointer, _id_hasWindowFocus as jni.JMethodIDPtr) + .boolean; + } + + static final _id_dispatchKeyEvent = _class.instanceMethodId( + r'dispatchKeyEvent', + r'(Landroid/view/KeyEvent;)Z', + ); + + static final _dispatchKeyEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean dispatchKeyEvent(android.view.KeyEvent keyEvent) + bool dispatchKeyEvent( + jni.JObject keyEvent, + ) { + return _dispatchKeyEvent( + reference.pointer, + _id_dispatchKeyEvent as jni.JMethodIDPtr, + keyEvent.reference.pointer) + .boolean; + } + + static final _id_dispatchKeyShortcutEvent = _class.instanceMethodId( + r'dispatchKeyShortcutEvent', + r'(Landroid/view/KeyEvent;)Z', + ); + + static final _dispatchKeyShortcutEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean dispatchKeyShortcutEvent(android.view.KeyEvent keyEvent) + bool dispatchKeyShortcutEvent( + jni.JObject keyEvent, + ) { + return _dispatchKeyShortcutEvent( + reference.pointer, + _id_dispatchKeyShortcutEvent as jni.JMethodIDPtr, + keyEvent.reference.pointer) + .boolean; + } + + static final _id_dispatchTouchEvent = _class.instanceMethodId( + r'dispatchTouchEvent', + r'(Landroid/view/MotionEvent;)Z', + ); + + static final _dispatchTouchEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean dispatchTouchEvent(android.view.MotionEvent motionEvent) + bool dispatchTouchEvent( + jni.JObject motionEvent, + ) { + return _dispatchTouchEvent( + reference.pointer, + _id_dispatchTouchEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) + .boolean; + } + + static final _id_dispatchTrackballEvent = _class.instanceMethodId( + r'dispatchTrackballEvent', + r'(Landroid/view/MotionEvent;)Z', + ); + + static final _dispatchTrackballEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean dispatchTrackballEvent(android.view.MotionEvent motionEvent) + bool dispatchTrackballEvent( + jni.JObject motionEvent, + ) { + return _dispatchTrackballEvent( + reference.pointer, + _id_dispatchTrackballEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) + .boolean; + } + + static final _id_dispatchGenericMotionEvent = _class.instanceMethodId( + r'dispatchGenericMotionEvent', + r'(Landroid/view/MotionEvent;)Z', + ); + + static final _dispatchGenericMotionEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean dispatchGenericMotionEvent(android.view.MotionEvent motionEvent) + bool dispatchGenericMotionEvent( + jni.JObject motionEvent, + ) { + return _dispatchGenericMotionEvent( + reference.pointer, + _id_dispatchGenericMotionEvent as jni.JMethodIDPtr, + motionEvent.reference.pointer) + .boolean; + } + + static final _id_dispatchPopulateAccessibilityEvent = _class.instanceMethodId( + r'dispatchPopulateAccessibilityEvent', + r'(Landroid/view/accessibility/AccessibilityEvent;)Z', + ); + + static final _dispatchPopulateAccessibilityEvent = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean dispatchPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent accessibilityEvent) + bool dispatchPopulateAccessibilityEvent( + jni.JObject accessibilityEvent, + ) { + return _dispatchPopulateAccessibilityEvent( + reference.pointer, + _id_dispatchPopulateAccessibilityEvent as jni.JMethodIDPtr, + accessibilityEvent.reference.pointer) + .boolean; + } + + static final _id_onCreatePanelView = _class.instanceMethodId( + r'onCreatePanelView', + r'(I)Landroid/view/View;', + ); + + static final _onCreatePanelView = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public android.view.View onCreatePanelView(int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject onCreatePanelView( + int i, + ) { + return _onCreatePanelView( + reference.pointer, _id_onCreatePanelView as jni.JMethodIDPtr, i) + .object(const jni.JObjectType()); + } + + static final _id_onCreatePanelMenu = _class.instanceMethodId( + r'onCreatePanelMenu', + r'(ILandroid/view/Menu;)Z', + ); + + static final _onCreatePanelMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public boolean onCreatePanelMenu(int i, android.view.Menu menu) + bool onCreatePanelMenu( + int i, + jni.JObject menu, + ) { + return _onCreatePanelMenu( + reference.pointer, + _id_onCreatePanelMenu as jni.JMethodIDPtr, + i, + menu.reference.pointer) + .boolean; + } + + static final _id_onPreparePanel = _class.instanceMethodId( + r'onPreparePanel', + r'(ILandroid/view/View;Landroid/view/Menu;)Z', + ); + + static final _onPreparePanel = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public boolean onPreparePanel(int i, android.view.View view, android.view.Menu menu) + bool onPreparePanel( + int i, + jni.JObject view, + jni.JObject menu, + ) { + return _onPreparePanel( + reference.pointer, + _id_onPreparePanel as jni.JMethodIDPtr, + i, + view.reference.pointer, + menu.reference.pointer) + .boolean; + } + + static final _id_onMenuOpened = _class.instanceMethodId( + r'onMenuOpened', + r'(ILandroid/view/Menu;)Z', + ); + + static final _onMenuOpened = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public boolean onMenuOpened(int i, android.view.Menu menu) + bool onMenuOpened( + int i, + jni.JObject menu, + ) { + return _onMenuOpened(reference.pointer, + _id_onMenuOpened as jni.JMethodIDPtr, i, menu.reference.pointer) + .boolean; + } + + static final _id_onMenuItemSelected = _class.instanceMethodId( + r'onMenuItemSelected', + r'(ILandroid/view/MenuItem;)Z', + ); + + static final _onMenuItemSelected = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public boolean onMenuItemSelected(int i, android.view.MenuItem menuItem) + bool onMenuItemSelected( + int i, + jni.JObject menuItem, + ) { + return _onMenuItemSelected( + reference.pointer, + _id_onMenuItemSelected as jni.JMethodIDPtr, + i, + menuItem.reference.pointer) + .boolean; + } + + static final _id_onPanelClosed = _class.instanceMethodId( + r'onPanelClosed', + r'(ILandroid/view/Menu;)V', + ); + + static final _onPanelClosed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: public void onPanelClosed(int i, android.view.Menu menu) + void onPanelClosed( + int i, + jni.JObject menu, + ) { + _onPanelClosed(reference.pointer, _id_onPanelClosed as jni.JMethodIDPtr, i, + menu.reference.pointer) + .check(); + } + + static final _id_invalidateOptionsMenu = _class.instanceMethodId( + r'invalidateOptionsMenu', + r'()V', + ); + + static final _invalidateOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void invalidateOptionsMenu() + void invalidateOptionsMenu() { + _invalidateOptionsMenu( + reference.pointer, _id_invalidateOptionsMenu as jni.JMethodIDPtr) + .check(); + } + + static final _id_onCreateOptionsMenu = _class.instanceMethodId( + r'onCreateOptionsMenu', + r'(Landroid/view/Menu;)Z', + ); + + static final _onCreateOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean onCreateOptionsMenu(android.view.Menu menu) + bool onCreateOptionsMenu( + jni.JObject menu, + ) { + return _onCreateOptionsMenu(reference.pointer, + _id_onCreateOptionsMenu as jni.JMethodIDPtr, menu.reference.pointer) + .boolean; + } + + static final _id_onPrepareOptionsMenu = _class.instanceMethodId( + r'onPrepareOptionsMenu', + r'(Landroid/view/Menu;)Z', + ); + + static final _onPrepareOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean onPrepareOptionsMenu(android.view.Menu menu) + bool onPrepareOptionsMenu( + jni.JObject menu, + ) { + return _onPrepareOptionsMenu( + reference.pointer, + _id_onPrepareOptionsMenu as jni.JMethodIDPtr, + menu.reference.pointer) + .boolean; + } + + static final _id_onOptionsItemSelected = _class.instanceMethodId( + r'onOptionsItemSelected', + r'(Landroid/view/MenuItem;)Z', + ); + + static final _onOptionsItemSelected = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean onOptionsItemSelected(android.view.MenuItem menuItem) + bool onOptionsItemSelected( + jni.JObject menuItem, + ) { + return _onOptionsItemSelected( + reference.pointer, + _id_onOptionsItemSelected as jni.JMethodIDPtr, + menuItem.reference.pointer) + .boolean; + } + + static final _id_onNavigateUp = _class.instanceMethodId( + r'onNavigateUp', + r'()Z', + ); + + static final _onNavigateUp = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean onNavigateUp() + bool onNavigateUp() { + return _onNavigateUp( + reference.pointer, _id_onNavigateUp as jni.JMethodIDPtr) + .boolean; + } + + static final _id_onNavigateUpFromChild = _class.instanceMethodId( + r'onNavigateUpFromChild', + r'(Landroid/app/Activity;)Z', + ); + + static final _onNavigateUpFromChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean onNavigateUpFromChild(android.app.Activity activity) + bool onNavigateUpFromChild( + Activity activity, + ) { + return _onNavigateUpFromChild( + reference.pointer, + _id_onNavigateUpFromChild as jni.JMethodIDPtr, + activity.reference.pointer) + .boolean; + } + + static final _id_onCreateNavigateUpTaskStack = _class.instanceMethodId( + r'onCreateNavigateUpTaskStack', + r'(Landroid/app/TaskStackBuilder;)V', + ); + + static final _onCreateNavigateUpTaskStack = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onCreateNavigateUpTaskStack(android.app.TaskStackBuilder taskStackBuilder) + void onCreateNavigateUpTaskStack( + jni.JObject taskStackBuilder, + ) { + _onCreateNavigateUpTaskStack( + reference.pointer, + _id_onCreateNavigateUpTaskStack as jni.JMethodIDPtr, + taskStackBuilder.reference.pointer) + .check(); + } + + static final _id_onPrepareNavigateUpTaskStack = _class.instanceMethodId( + r'onPrepareNavigateUpTaskStack', + r'(Landroid/app/TaskStackBuilder;)V', + ); + + static final _onPrepareNavigateUpTaskStack = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onPrepareNavigateUpTaskStack(android.app.TaskStackBuilder taskStackBuilder) + void onPrepareNavigateUpTaskStack( + jni.JObject taskStackBuilder, + ) { + _onPrepareNavigateUpTaskStack( + reference.pointer, + _id_onPrepareNavigateUpTaskStack as jni.JMethodIDPtr, + taskStackBuilder.reference.pointer) + .check(); + } + + static final _id_onOptionsMenuClosed = _class.instanceMethodId( + r'onOptionsMenuClosed', + r'(Landroid/view/Menu;)V', + ); + + static final _onOptionsMenuClosed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onOptionsMenuClosed(android.view.Menu menu) + void onOptionsMenuClosed( + jni.JObject menu, + ) { + _onOptionsMenuClosed(reference.pointer, + _id_onOptionsMenuClosed as jni.JMethodIDPtr, menu.reference.pointer) + .check(); + } + + static final _id_openOptionsMenu = _class.instanceMethodId( + r'openOptionsMenu', + r'()V', + ); + + static final _openOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void openOptionsMenu() + void openOptionsMenu() { + _openOptionsMenu(reference.pointer, _id_openOptionsMenu as jni.JMethodIDPtr) + .check(); + } + + static final _id_closeOptionsMenu = _class.instanceMethodId( + r'closeOptionsMenu', + r'()V', + ); + + static final _closeOptionsMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void closeOptionsMenu() + void closeOptionsMenu() { + _closeOptionsMenu( + reference.pointer, _id_closeOptionsMenu as jni.JMethodIDPtr) + .check(); + } + + static final _id_onCreateContextMenu = _class.instanceMethodId( + r'onCreateContextMenu', + r'(Landroid/view/ContextMenu;Landroid/view/View;Landroid/view/ContextMenu$ContextMenuInfo;)V', + ); + + static final _onCreateContextMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public void onCreateContextMenu(android.view.ContextMenu contextMenu, android.view.View view, android.view.ContextMenu$ContextMenuInfo contextMenuInfo) + void onCreateContextMenu( + jni.JObject contextMenu, + jni.JObject view, + jni.JObject contextMenuInfo, + ) { + _onCreateContextMenu( + reference.pointer, + _id_onCreateContextMenu as jni.JMethodIDPtr, + contextMenu.reference.pointer, + view.reference.pointer, + contextMenuInfo.reference.pointer) + .check(); + } + + static final _id_registerForContextMenu = _class.instanceMethodId( + r'registerForContextMenu', + r'(Landroid/view/View;)V', + ); + + static final _registerForContextMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void registerForContextMenu(android.view.View view) + void registerForContextMenu( + jni.JObject view, + ) { + _registerForContextMenu( + reference.pointer, + _id_registerForContextMenu as jni.JMethodIDPtr, + view.reference.pointer) + .check(); + } + + static final _id_unregisterForContextMenu = _class.instanceMethodId( + r'unregisterForContextMenu', + r'(Landroid/view/View;)V', + ); + + static final _unregisterForContextMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void unregisterForContextMenu(android.view.View view) + void unregisterForContextMenu( + jni.JObject view, + ) { + _unregisterForContextMenu( + reference.pointer, + _id_unregisterForContextMenu as jni.JMethodIDPtr, + view.reference.pointer) + .check(); + } + + static final _id_openContextMenu = _class.instanceMethodId( + r'openContextMenu', + r'(Landroid/view/View;)V', + ); + + static final _openContextMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void openContextMenu(android.view.View view) + void openContextMenu( + jni.JObject view, + ) { + _openContextMenu(reference.pointer, _id_openContextMenu as jni.JMethodIDPtr, + view.reference.pointer) + .check(); + } + + static final _id_closeContextMenu = _class.instanceMethodId( + r'closeContextMenu', + r'()V', + ); + + static final _closeContextMenu = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void closeContextMenu() + void closeContextMenu() { + _closeContextMenu( + reference.pointer, _id_closeContextMenu as jni.JMethodIDPtr) + .check(); + } + + static final _id_onContextItemSelected = _class.instanceMethodId( + r'onContextItemSelected', + r'(Landroid/view/MenuItem;)Z', + ); + + static final _onContextItemSelected = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean onContextItemSelected(android.view.MenuItem menuItem) + bool onContextItemSelected( + jni.JObject menuItem, + ) { + return _onContextItemSelected( + reference.pointer, + _id_onContextItemSelected as jni.JMethodIDPtr, + menuItem.reference.pointer) + .boolean; + } + + static final _id_onContextMenuClosed = _class.instanceMethodId( + r'onContextMenuClosed', + r'(Landroid/view/Menu;)V', + ); + + static final _onContextMenuClosed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onContextMenuClosed(android.view.Menu menu) + void onContextMenuClosed( + jni.JObject menu, + ) { + _onContextMenuClosed(reference.pointer, + _id_onContextMenuClosed as jni.JMethodIDPtr, menu.reference.pointer) + .check(); + } + + static final _id_onCreateDialog = _class.instanceMethodId( + r'onCreateDialog', + r'(I)Landroid/app/Dialog;', + ); + + static final _onCreateDialog = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: protected android.app.Dialog onCreateDialog(int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject onCreateDialog( + int i, + ) { + return _onCreateDialog( + reference.pointer, _id_onCreateDialog as jni.JMethodIDPtr, i) + .object(const jni.JObjectType()); + } + + static final _id_onCreateDialog1 = _class.instanceMethodId( + r'onCreateDialog', + r'(ILandroid/os/Bundle;)Landroid/app/Dialog;', + ); + + static final _onCreateDialog1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: protected android.app.Dialog onCreateDialog(int i, android.os.Bundle bundle) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject onCreateDialog1( + int i, + Bundle bundle, + ) { + return _onCreateDialog1( + reference.pointer, + _id_onCreateDialog1 as jni.JMethodIDPtr, + i, + bundle.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_onPrepareDialog = _class.instanceMethodId( + r'onPrepareDialog', + r'(ILandroid/app/Dialog;)V', + ); + + static final _onPrepareDialog = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: protected void onPrepareDialog(int i, android.app.Dialog dialog) + void onPrepareDialog( + int i, + jni.JObject dialog, + ) { + _onPrepareDialog(reference.pointer, _id_onPrepareDialog as jni.JMethodIDPtr, + i, dialog.reference.pointer) + .check(); + } + + static final _id_onPrepareDialog1 = _class.instanceMethodId( + r'onPrepareDialog', + r'(ILandroid/app/Dialog;Landroid/os/Bundle;)V', + ); + + static final _onPrepareDialog1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer, ffi.Pointer)>(); + + /// from: protected void onPrepareDialog(int i, android.app.Dialog dialog, android.os.Bundle bundle) + void onPrepareDialog1( + int i, + jni.JObject dialog, + Bundle bundle, + ) { + _onPrepareDialog1( + reference.pointer, + _id_onPrepareDialog1 as jni.JMethodIDPtr, + i, + dialog.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_showDialog = _class.instanceMethodId( + r'showDialog', + r'(I)V', + ); + + static final _showDialog = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void showDialog(int i) + void showDialog( + int i, + ) { + _showDialog(reference.pointer, _id_showDialog as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_showDialog1 = _class.instanceMethodId( + r'showDialog', + r'(ILandroid/os/Bundle;)Z', + ); + + static final _showDialog1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public final boolean showDialog(int i, android.os.Bundle bundle) + bool showDialog1( + int i, + Bundle bundle, + ) { + return _showDialog1(reference.pointer, _id_showDialog1 as jni.JMethodIDPtr, + i, bundle.reference.pointer) + .boolean; + } + + static final _id_dismissDialog = _class.instanceMethodId( + r'dismissDialog', + r'(I)V', + ); + + static final _dismissDialog = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void dismissDialog(int i) + void dismissDialog( + int i, + ) { + _dismissDialog(reference.pointer, _id_dismissDialog as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_removeDialog = _class.instanceMethodId( + r'removeDialog', + r'(I)V', + ); + + static final _removeDialog = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void removeDialog(int i) + void removeDialog( + int i, + ) { + _removeDialog(reference.pointer, _id_removeDialog as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_onSearchRequested = _class.instanceMethodId( + r'onSearchRequested', + r'(Landroid/view/SearchEvent;)Z', + ); + + static final _onSearchRequested = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean onSearchRequested(android.view.SearchEvent searchEvent) + bool onSearchRequested( + jni.JObject searchEvent, + ) { + return _onSearchRequested( + reference.pointer, + _id_onSearchRequested as jni.JMethodIDPtr, + searchEvent.reference.pointer) + .boolean; + } + + static final _id_onSearchRequested1 = _class.instanceMethodId( + r'onSearchRequested', + r'()Z', + ); + + static final _onSearchRequested1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean onSearchRequested() + bool onSearchRequested1() { + return _onSearchRequested1( + reference.pointer, _id_onSearchRequested1 as jni.JMethodIDPtr) + .boolean; + } + + static final _id_getSearchEvent = _class.instanceMethodId( + r'getSearchEvent', + r'()Landroid/view/SearchEvent;', + ); + + static final _getSearchEvent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.view.SearchEvent getSearchEvent() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSearchEvent() { + return _getSearchEvent( + reference.pointer, _id_getSearchEvent as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_startSearch = _class.instanceMethodId( + r'startSearch', + r'(Ljava/lang/String;ZLandroid/os/Bundle;Z)V', + ); + + static final _startSearch = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer, int)>(); + + /// from: public void startSearch(java.lang.String string, boolean z, android.os.Bundle bundle, boolean z1) + void startSearch( + jni.JString string, + bool z, + Bundle bundle, + bool z1, + ) { + _startSearch( + reference.pointer, + _id_startSearch as jni.JMethodIDPtr, + string.reference.pointer, + z ? 1 : 0, + bundle.reference.pointer, + z1 ? 1 : 0) + .check(); + } + + static final _id_triggerSearch = _class.instanceMethodId( + r'triggerSearch', + r'(Ljava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _triggerSearch = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void triggerSearch(java.lang.String string, android.os.Bundle bundle) + void triggerSearch( + jni.JString string, + Bundle bundle, + ) { + _triggerSearch(reference.pointer, _id_triggerSearch as jni.JMethodIDPtr, + string.reference.pointer, bundle.reference.pointer) + .check(); + } + + static final _id_takeKeyEvents = _class.instanceMethodId( + r'takeKeyEvents', + r'(Z)V', + ); + + static final _takeKeyEvents = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void takeKeyEvents(boolean z) + void takeKeyEvents( + bool z, + ) { + _takeKeyEvents( + reference.pointer, _id_takeKeyEvents as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_requestWindowFeature = _class.instanceMethodId( + r'requestWindowFeature', + r'(I)Z', + ); + + static final _requestWindowFeature = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final boolean requestWindowFeature(int i) + bool requestWindowFeature( + int i, + ) { + return _requestWindowFeature( + reference.pointer, _id_requestWindowFeature as jni.JMethodIDPtr, i) + .boolean; + } + + static final _id_setFeatureDrawableResource = _class.instanceMethodId( + r'setFeatureDrawableResource', + r'(II)V', + ); + + static final _setFeatureDrawableResource = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, $Int32)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int)>(); + + /// from: public final void setFeatureDrawableResource(int i, int i1) + void setFeatureDrawableResource( + int i, + int i1, + ) { + _setFeatureDrawableResource(reference.pointer, + _id_setFeatureDrawableResource as jni.JMethodIDPtr, i, i1) + .check(); + } + + static final _id_setFeatureDrawableUri = _class.instanceMethodId( + r'setFeatureDrawableUri', + r'(ILandroid/net/Uri;)V', + ); + + static final _setFeatureDrawableUri = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: public final void setFeatureDrawableUri(int i, android.net.Uri uri) + void setFeatureDrawableUri( + int i, + Uri uri, + ) { + _setFeatureDrawableUri( + reference.pointer, + _id_setFeatureDrawableUri as jni.JMethodIDPtr, + i, + uri.reference.pointer) + .check(); + } + + static final _id_setFeatureDrawable = _class.instanceMethodId( + r'setFeatureDrawable', + r'(ILandroid/graphics/drawable/Drawable;)V', + ); + + static final _setFeatureDrawable = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: public final void setFeatureDrawable(int i, android.graphics.drawable.Drawable drawable) + void setFeatureDrawable( + int i, + jni.JObject drawable, + ) { + _setFeatureDrawable( + reference.pointer, + _id_setFeatureDrawable as jni.JMethodIDPtr, + i, + drawable.reference.pointer) + .check(); + } + + static final _id_setFeatureDrawableAlpha = _class.instanceMethodId( + r'setFeatureDrawableAlpha', + r'(II)V', + ); + + static final _setFeatureDrawableAlpha = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, $Int32)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int)>(); + + /// from: public final void setFeatureDrawableAlpha(int i, int i1) + void setFeatureDrawableAlpha( + int i, + int i1, + ) { + _setFeatureDrawableAlpha(reference.pointer, + _id_setFeatureDrawableAlpha as jni.JMethodIDPtr, i, i1) + .check(); + } + + static final _id_getLayoutInflater = _class.instanceMethodId( + r'getLayoutInflater', + r'()Landroid/view/LayoutInflater;', + ); + + static final _getLayoutInflater = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.view.LayoutInflater getLayoutInflater() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getLayoutInflater() { + return _getLayoutInflater( + reference.pointer, _id_getLayoutInflater as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getMenuInflater = _class.instanceMethodId( + r'getMenuInflater', + r'()Landroid/view/MenuInflater;', + ); + + static final _getMenuInflater = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.view.MenuInflater getMenuInflater() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getMenuInflater() { + return _getMenuInflater( + reference.pointer, _id_getMenuInflater as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_setTheme = _class.instanceMethodId( + r'setTheme', + r'(I)V', + ); + + static final _setTheme = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setTheme(int i) + void setTheme( + int i, + ) { + _setTheme(reference.pointer, _id_setTheme as jni.JMethodIDPtr, i).check(); + } + + static final _id_onApplyThemeResource = _class.instanceMethodId( + r'onApplyThemeResource', + r'(Landroid/content/res/Resources$Theme;IZ)V', + ); + + static final _onApplyThemeResource = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int)>(); + + /// from: protected void onApplyThemeResource(android.content.res.Resources$Theme theme, int i, boolean z) + void onApplyThemeResource( + jni.JObject theme, + int i, + bool z, + ) { + _onApplyThemeResource( + reference.pointer, + _id_onApplyThemeResource as jni.JMethodIDPtr, + theme.reference.pointer, + i, + z ? 1 : 0) + .check(); + } + + static final _id_requestPermissions = _class.instanceMethodId( + r'requestPermissions', + r'([Ljava/lang/String;I)V', + ); + + static final _requestPermissions = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public final void requestPermissions(java.lang.String[] strings, int i) + void requestPermissions( + jni.JArray strings, + int i, + ) { + _requestPermissions( + reference.pointer, + _id_requestPermissions as jni.JMethodIDPtr, + strings.reference.pointer, + i) + .check(); + } + + static final _id_onRequestPermissionsResult = _class.instanceMethodId( + r'onRequestPermissionsResult', + r'(I[Ljava/lang/String;[I)V', + ); + + static final _onRequestPermissionsResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer, ffi.Pointer)>(); + + /// from: public void onRequestPermissionsResult(int i, java.lang.String[] strings, int[] is) + void onRequestPermissionsResult( + int i, + jni.JArray strings, + jni.JArray is0, + ) { + _onRequestPermissionsResult( + reference.pointer, + _id_onRequestPermissionsResult as jni.JMethodIDPtr, + i, + strings.reference.pointer, + is0.reference.pointer) + .check(); + } + + static final _id_shouldShowRequestPermissionRationale = + _class.instanceMethodId( + r'shouldShowRequestPermissionRationale', + r'(Ljava/lang/String;)Z', + ); + + static final _shouldShowRequestPermissionRationale = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean shouldShowRequestPermissionRationale(java.lang.String string) + bool shouldShowRequestPermissionRationale( + jni.JString string, + ) { + return _shouldShowRequestPermissionRationale( + reference.pointer, + _id_shouldShowRequestPermissionRationale as jni.JMethodIDPtr, + string.reference.pointer) + .boolean; + } + + static final _id_startActivityForResult = _class.instanceMethodId( + r'startActivityForResult', + r'(Landroid/content/Intent;I)V', + ); + + static final _startActivityForResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public void startActivityForResult(android.content.Intent intent, int i) + void startActivityForResult( + jni.JObject intent, + int i, + ) { + _startActivityForResult( + reference.pointer, + _id_startActivityForResult as jni.JMethodIDPtr, + intent.reference.pointer, + i) + .check(); + } + + static final _id_startActivityForResult1 = _class.instanceMethodId( + r'startActivityForResult', + r'(Landroid/content/Intent;ILandroid/os/Bundle;)V', + ); + + static final _startActivityForResult1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); + + /// from: public void startActivityForResult(android.content.Intent intent, int i, android.os.Bundle bundle) + void startActivityForResult1( + jni.JObject intent, + int i, + Bundle bundle, + ) { + _startActivityForResult1( + reference.pointer, + _id_startActivityForResult1 as jni.JMethodIDPtr, + intent.reference.pointer, + i, + bundle.reference.pointer) + .check(); + } + + static final _id_isActivityTransitionRunning = _class.instanceMethodId( + r'isActivityTransitionRunning', + r'()Z', + ); + + static final _isActivityTransitionRunning = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isActivityTransitionRunning() + bool isActivityTransitionRunning() { + return _isActivityTransitionRunning(reference.pointer, + _id_isActivityTransitionRunning as jni.JMethodIDPtr) + .boolean; + } + + static final _id_startIntentSenderForResult = _class.instanceMethodId( + r'startIntentSenderForResult', + r'(Landroid/content/IntentSender;ILandroid/content/Intent;III)V', + ); + + static final _startIntentSenderForResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer, + $Int32, + $Int32, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer, + int, + int, + int)>(); + + /// from: public void startIntentSenderForResult(android.content.IntentSender intentSender, int i, android.content.Intent intent, int i1, int i2, int i3) + void startIntentSenderForResult( + jni.JObject intentSender, + int i, + jni.JObject intent, + int i1, + int i2, + int i3, + ) { + _startIntentSenderForResult( + reference.pointer, + _id_startIntentSenderForResult as jni.JMethodIDPtr, + intentSender.reference.pointer, + i, + intent.reference.pointer, + i1, + i2, + i3) + .check(); + } + + static final _id_startIntentSenderForResult1 = _class.instanceMethodId( + r'startIntentSenderForResult', + r'(Landroid/content/IntentSender;ILandroid/content/Intent;IIILandroid/os/Bundle;)V', + ); + + static final _startIntentSenderForResult1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer, + $Int32, + $Int32, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer, + int, + int, + int, + ffi.Pointer)>(); + + /// from: public void startIntentSenderForResult(android.content.IntentSender intentSender, int i, android.content.Intent intent, int i1, int i2, int i3, android.os.Bundle bundle) + void startIntentSenderForResult1( + jni.JObject intentSender, + int i, + jni.JObject intent, + int i1, + int i2, + int i3, + Bundle bundle, + ) { + _startIntentSenderForResult1( + reference.pointer, + _id_startIntentSenderForResult1 as jni.JMethodIDPtr, + intentSender.reference.pointer, + i, + intent.reference.pointer, + i1, + i2, + i3, + bundle.reference.pointer) + .check(); + } + + static final _id_startActivity = _class.instanceMethodId( + r'startActivity', + r'(Landroid/content/Intent;)V', + ); + + static final _startActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void startActivity(android.content.Intent intent) + void startActivity( + jni.JObject intent, + ) { + _startActivity(reference.pointer, _id_startActivity as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); + } + + static final _id_startActivity1 = _class.instanceMethodId( + r'startActivity', + r'(Landroid/content/Intent;Landroid/os/Bundle;)V', + ); + + static final _startActivity1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void startActivity(android.content.Intent intent, android.os.Bundle bundle) + void startActivity1( + jni.JObject intent, + Bundle bundle, + ) { + _startActivity1(reference.pointer, _id_startActivity1 as jni.JMethodIDPtr, + intent.reference.pointer, bundle.reference.pointer) + .check(); + } + + static final _id_startActivities = _class.instanceMethodId( + r'startActivities', + r'([Landroid/content/Intent;)V', + ); + + static final _startActivities = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void startActivities(android.content.Intent[] intents) + void startActivities( + jni.JArray intents, + ) { + _startActivities(reference.pointer, _id_startActivities as jni.JMethodIDPtr, + intents.reference.pointer) + .check(); + } + + static final _id_startActivities1 = _class.instanceMethodId( + r'startActivities', + r'([Landroid/content/Intent;Landroid/os/Bundle;)V', + ); + + static final _startActivities1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void startActivities(android.content.Intent[] intents, android.os.Bundle bundle) + void startActivities1( + jni.JArray intents, + Bundle bundle, + ) { + _startActivities1( + reference.pointer, + _id_startActivities1 as jni.JMethodIDPtr, + intents.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_startIntentSender = _class.instanceMethodId( + r'startIntentSender', + r'(Landroid/content/IntentSender;Landroid/content/Intent;III)V', + ); + + static final _startIntentSender = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + $Int32, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int, int, int)>(); + + /// from: public void startIntentSender(android.content.IntentSender intentSender, android.content.Intent intent, int i, int i1, int i2) + void startIntentSender( + jni.JObject intentSender, + jni.JObject intent, + int i, + int i1, + int i2, + ) { + _startIntentSender( + reference.pointer, + _id_startIntentSender as jni.JMethodIDPtr, + intentSender.reference.pointer, + intent.reference.pointer, + i, + i1, + i2) + .check(); + } + + static final _id_startIntentSender1 = _class.instanceMethodId( + r'startIntentSender', + r'(Landroid/content/IntentSender;Landroid/content/Intent;IIILandroid/os/Bundle;)V', + ); + + static final _startIntentSender1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + $Int32, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer)>(); + + /// from: public void startIntentSender(android.content.IntentSender intentSender, android.content.Intent intent, int i, int i1, int i2, android.os.Bundle bundle) + void startIntentSender1( + jni.JObject intentSender, + jni.JObject intent, + int i, + int i1, + int i2, + Bundle bundle, + ) { + _startIntentSender1( + reference.pointer, + _id_startIntentSender1 as jni.JMethodIDPtr, + intentSender.reference.pointer, + intent.reference.pointer, + i, + i1, + i2, + bundle.reference.pointer) + .check(); + } + + static final _id_startActivityIfNeeded = _class.instanceMethodId( + r'startActivityIfNeeded', + r'(Landroid/content/Intent;I)Z', + ); + + static final _startActivityIfNeeded = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public boolean startActivityIfNeeded(android.content.Intent intent, int i) + bool startActivityIfNeeded( + jni.JObject intent, + int i, + ) { + return _startActivityIfNeeded( + reference.pointer, + _id_startActivityIfNeeded as jni.JMethodIDPtr, + intent.reference.pointer, + i) + .boolean; + } + + static final _id_startActivityIfNeeded1 = _class.instanceMethodId( + r'startActivityIfNeeded', + r'(Landroid/content/Intent;ILandroid/os/Bundle;)Z', + ); + + static final _startActivityIfNeeded1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); + + /// from: public boolean startActivityIfNeeded(android.content.Intent intent, int i, android.os.Bundle bundle) + bool startActivityIfNeeded1( + jni.JObject intent, + int i, + Bundle bundle, + ) { + return _startActivityIfNeeded1( + reference.pointer, + _id_startActivityIfNeeded1 as jni.JMethodIDPtr, + intent.reference.pointer, + i, + bundle.reference.pointer) + .boolean; + } + + static final _id_startNextMatchingActivity = _class.instanceMethodId( + r'startNextMatchingActivity', + r'(Landroid/content/Intent;)Z', + ); + + static final _startNextMatchingActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean startNextMatchingActivity(android.content.Intent intent) + bool startNextMatchingActivity( + jni.JObject intent, + ) { + return _startNextMatchingActivity( + reference.pointer, + _id_startNextMatchingActivity as jni.JMethodIDPtr, + intent.reference.pointer) + .boolean; + } + + static final _id_startNextMatchingActivity1 = _class.instanceMethodId( + r'startNextMatchingActivity', + r'(Landroid/content/Intent;Landroid/os/Bundle;)Z', + ); + + static final _startNextMatchingActivity1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public boolean startNextMatchingActivity(android.content.Intent intent, android.os.Bundle bundle) + bool startNextMatchingActivity1( + jni.JObject intent, + Bundle bundle, + ) { + return _startNextMatchingActivity1( + reference.pointer, + _id_startNextMatchingActivity1 as jni.JMethodIDPtr, + intent.reference.pointer, + bundle.reference.pointer) + .boolean; + } + + static final _id_startActivityFromChild = _class.instanceMethodId( + r'startActivityFromChild', + r'(Landroid/app/Activity;Landroid/content/Intent;I)V', + ); + + static final _startActivityFromChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); + + /// from: public void startActivityFromChild(android.app.Activity activity, android.content.Intent intent, int i) + void startActivityFromChild( + Activity activity, + jni.JObject intent, + int i, + ) { + _startActivityFromChild( + reference.pointer, + _id_startActivityFromChild as jni.JMethodIDPtr, + activity.reference.pointer, + intent.reference.pointer, + i) + .check(); + } + + static final _id_startActivityFromChild1 = _class.instanceMethodId( + r'startActivityFromChild', + r'(Landroid/app/Activity;Landroid/content/Intent;ILandroid/os/Bundle;)V', + ); + + static final _startActivityFromChild1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); + + /// from: public void startActivityFromChild(android.app.Activity activity, android.content.Intent intent, int i, android.os.Bundle bundle) + void startActivityFromChild1( + Activity activity, + jni.JObject intent, + int i, + Bundle bundle, + ) { + _startActivityFromChild1( + reference.pointer, + _id_startActivityFromChild1 as jni.JMethodIDPtr, + activity.reference.pointer, + intent.reference.pointer, + i, + bundle.reference.pointer) + .check(); + } + + static final _id_startActivityFromFragment = _class.instanceMethodId( + r'startActivityFromFragment', + r'(Landroid/app/Fragment;Landroid/content/Intent;I)V', + ); + + static final _startActivityFromFragment = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); + + /// from: public void startActivityFromFragment(android.app.Fragment fragment, android.content.Intent intent, int i) + void startActivityFromFragment( + jni.JObject fragment, + jni.JObject intent, + int i, + ) { + _startActivityFromFragment( + reference.pointer, + _id_startActivityFromFragment as jni.JMethodIDPtr, + fragment.reference.pointer, + intent.reference.pointer, + i) + .check(); + } + + static final _id_startActivityFromFragment1 = _class.instanceMethodId( + r'startActivityFromFragment', + r'(Landroid/app/Fragment;Landroid/content/Intent;ILandroid/os/Bundle;)V', + ); + + static final _startActivityFromFragment1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); + + /// from: public void startActivityFromFragment(android.app.Fragment fragment, android.content.Intent intent, int i, android.os.Bundle bundle) + void startActivityFromFragment1( + jni.JObject fragment, + jni.JObject intent, + int i, + Bundle bundle, + ) { + _startActivityFromFragment1( + reference.pointer, + _id_startActivityFromFragment1 as jni.JMethodIDPtr, + fragment.reference.pointer, + intent.reference.pointer, + i, + bundle.reference.pointer) + .check(); + } + + static final _id_startIntentSenderFromChild = _class.instanceMethodId( + r'startIntentSenderFromChild', + r'(Landroid/app/Activity;Landroid/content/IntentSender;ILandroid/content/Intent;III)V', + ); + + static final _startIntentSenderFromChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer, + $Int32, + $Int32, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + int, + int, + int)>(); + + /// from: public void startIntentSenderFromChild(android.app.Activity activity, android.content.IntentSender intentSender, int i, android.content.Intent intent, int i1, int i2, int i3) + void startIntentSenderFromChild( + Activity activity, + jni.JObject intentSender, + int i, + jni.JObject intent, + int i1, + int i2, + int i3, + ) { + _startIntentSenderFromChild( + reference.pointer, + _id_startIntentSenderFromChild as jni.JMethodIDPtr, + activity.reference.pointer, + intentSender.reference.pointer, + i, + intent.reference.pointer, + i1, + i2, + i3) + .check(); + } + + static final _id_startIntentSenderFromChild1 = _class.instanceMethodId( + r'startIntentSenderFromChild', + r'(Landroid/app/Activity;Landroid/content/IntentSender;ILandroid/content/Intent;IIILandroid/os/Bundle;)V', + ); + + static final _startIntentSenderFromChild1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer, + $Int32, + $Int32, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + int, + int, + int, + ffi.Pointer)>(); + + /// from: public void startIntentSenderFromChild(android.app.Activity activity, android.content.IntentSender intentSender, int i, android.content.Intent intent, int i1, int i2, int i3, android.os.Bundle bundle) + void startIntentSenderFromChild1( + Activity activity, + jni.JObject intentSender, + int i, + jni.JObject intent, + int i1, + int i2, + int i3, + Bundle bundle, + ) { + _startIntentSenderFromChild1( + reference.pointer, + _id_startIntentSenderFromChild1 as jni.JMethodIDPtr, + activity.reference.pointer, + intentSender.reference.pointer, + i, + intent.reference.pointer, + i1, + i2, + i3, + bundle.reference.pointer) + .check(); + } + + static final _id_overrideActivityTransition = _class.instanceMethodId( + r'overrideActivityTransition', + r'(III)V', + ); + + static final _overrideActivityTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, $Int32, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int, int)>(); + + /// from: public void overrideActivityTransition(int i, int i1, int i2) + void overrideActivityTransition( + int i, + int i1, + int i2, + ) { + _overrideActivityTransition(reference.pointer, + _id_overrideActivityTransition as jni.JMethodIDPtr, i, i1, i2) + .check(); + } + + static final _id_overrideActivityTransition1 = _class.instanceMethodId( + r'overrideActivityTransition', + r'(IIII)V', + ); + + static final _overrideActivityTransition1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, $Int32, $Int32, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int, int, int)>(); + + /// from: public void overrideActivityTransition(int i, int i1, int i2, int i3) + void overrideActivityTransition1( + int i, + int i1, + int i2, + int i3, + ) { + _overrideActivityTransition1(reference.pointer, + _id_overrideActivityTransition1 as jni.JMethodIDPtr, i, i1, i2, i3) + .check(); + } + + static final _id_clearOverrideActivityTransition = _class.instanceMethodId( + r'clearOverrideActivityTransition', + r'(I)V', + ); + + static final _clearOverrideActivityTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void clearOverrideActivityTransition(int i) + void clearOverrideActivityTransition( + int i, + ) { + _clearOverrideActivityTransition(reference.pointer, + _id_clearOverrideActivityTransition as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_overridePendingTransition = _class.instanceMethodId( + r'overridePendingTransition', + r'(II)V', + ); + + static final _overridePendingTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, $Int32)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int)>(); + + /// from: public void overridePendingTransition(int i, int i1) + void overridePendingTransition( + int i, + int i1, + ) { + _overridePendingTransition(reference.pointer, + _id_overridePendingTransition as jni.JMethodIDPtr, i, i1) + .check(); + } + + static final _id_overridePendingTransition1 = _class.instanceMethodId( + r'overridePendingTransition', + r'(III)V', + ); + + static final _overridePendingTransition1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, $Int32, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int, int, int)>(); + + /// from: public void overridePendingTransition(int i, int i1, int i2) + void overridePendingTransition1( + int i, + int i1, + int i2, + ) { + _overridePendingTransition1(reference.pointer, + _id_overridePendingTransition1 as jni.JMethodIDPtr, i, i1, i2) + .check(); + } + + static final _id_setResult = _class.instanceMethodId( + r'setResult', + r'(I)V', + ); + + static final _setResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void setResult(int i) + void setResult( + int i, + ) { + _setResult(reference.pointer, _id_setResult as jni.JMethodIDPtr, i).check(); + } + + static final _id_setResult1 = _class.instanceMethodId( + r'setResult', + r'(ILandroid/content/Intent;)V', + ); + + static final _setResult1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: public final void setResult(int i, android.content.Intent intent) + void setResult1( + int i, + jni.JObject intent, + ) { + _setResult1(reference.pointer, _id_setResult1 as jni.JMethodIDPtr, i, + intent.reference.pointer) + .check(); + } + + static final _id_getReferrer = _class.instanceMethodId( + r'getReferrer', + r'()Landroid/net/Uri;', + ); + + static final _getReferrer = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.net.Uri getReferrer() + /// The returned object must be released after use, by calling the [release] method. + Uri getReferrer() { + return _getReferrer(reference.pointer, _id_getReferrer as jni.JMethodIDPtr) + .object(const $UriType()); + } + + static final _id_onProvideReferrer = _class.instanceMethodId( + r'onProvideReferrer', + r'()Landroid/net/Uri;', + ); + + static final _onProvideReferrer = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.net.Uri onProvideReferrer() + /// The returned object must be released after use, by calling the [release] method. + Uri onProvideReferrer() { + return _onProvideReferrer( + reference.pointer, _id_onProvideReferrer as jni.JMethodIDPtr) + .object(const $UriType()); + } + + static final _id_getCallingPackage = _class.instanceMethodId( + r'getCallingPackage', + r'()Ljava/lang/String;', + ); + + static final _getCallingPackage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getCallingPackage() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getCallingPackage() { + return _getCallingPackage( + reference.pointer, _id_getCallingPackage as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getCallingActivity = _class.instanceMethodId( + r'getCallingActivity', + r'()Landroid/content/ComponentName;', + ); + + static final _getCallingActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.content.ComponentName getCallingActivity() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getCallingActivity() { + return _getCallingActivity( + reference.pointer, _id_getCallingActivity as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getLaunchedFromUid = _class.instanceMethodId( + r'getLaunchedFromUid', + r'()I', + ); + + static final _getLaunchedFromUid = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int getLaunchedFromUid() + int getLaunchedFromUid() { + return _getLaunchedFromUid( + reference.pointer, _id_getLaunchedFromUid as jni.JMethodIDPtr) + .integer; + } + + static final _id_getLaunchedFromPackage = _class.instanceMethodId( + r'getLaunchedFromPackage', + r'()Ljava/lang/String;', + ); + + static final _getLaunchedFromPackage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getLaunchedFromPackage() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getLaunchedFromPackage() { + return _getLaunchedFromPackage( + reference.pointer, _id_getLaunchedFromPackage as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_setVisible = _class.instanceMethodId( + r'setVisible', + r'(Z)V', + ); + + static final _setVisible = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setVisible(boolean z) + void setVisible( + bool z, + ) { + _setVisible( + reference.pointer, _id_setVisible as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_isFinishing = _class.instanceMethodId( + r'isFinishing', + r'()Z', + ); + + static final _isFinishing = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isFinishing() + bool isFinishing() { + return _isFinishing(reference.pointer, _id_isFinishing as jni.JMethodIDPtr) + .boolean; + } + + static final _id_isDestroyed = _class.instanceMethodId( + r'isDestroyed', + r'()Z', + ); + + static final _isDestroyed = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isDestroyed() + bool isDestroyed() { + return _isDestroyed(reference.pointer, _id_isDestroyed as jni.JMethodIDPtr) + .boolean; + } + + static final _id_isChangingConfigurations = _class.instanceMethodId( + r'isChangingConfigurations', + r'()Z', + ); + + static final _isChangingConfigurations = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isChangingConfigurations() + bool isChangingConfigurations() { + return _isChangingConfigurations( + reference.pointer, _id_isChangingConfigurations as jni.JMethodIDPtr) + .boolean; + } + + static final _id_recreate = _class.instanceMethodId( + r'recreate', + r'()V', + ); + + static final _recreate = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void recreate() + void recreate() { + _recreate(reference.pointer, _id_recreate as jni.JMethodIDPtr).check(); + } + + static final _id_finish = _class.instanceMethodId( + r'finish', + r'()V', + ); + + static final _finish = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void finish() + void finish() { + _finish(reference.pointer, _id_finish as jni.JMethodIDPtr).check(); + } + + static final _id_finishAffinity = _class.instanceMethodId( + r'finishAffinity', + r'()V', + ); + + static final _finishAffinity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void finishAffinity() + void finishAffinity() { + _finishAffinity(reference.pointer, _id_finishAffinity as jni.JMethodIDPtr) + .check(); + } + + static final _id_finishFromChild = _class.instanceMethodId( + r'finishFromChild', + r'(Landroid/app/Activity;)V', + ); + + static final _finishFromChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void finishFromChild(android.app.Activity activity) + void finishFromChild( + Activity activity, + ) { + _finishFromChild(reference.pointer, _id_finishFromChild as jni.JMethodIDPtr, + activity.reference.pointer) + .check(); + } + + static final _id_finishAfterTransition = _class.instanceMethodId( + r'finishAfterTransition', + r'()V', + ); + + static final _finishAfterTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void finishAfterTransition() + void finishAfterTransition() { + _finishAfterTransition( + reference.pointer, _id_finishAfterTransition as jni.JMethodIDPtr) + .check(); + } + + static final _id_finishActivity = _class.instanceMethodId( + r'finishActivity', + r'(I)V', + ); + + static final _finishActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void finishActivity(int i) + void finishActivity( + int i, + ) { + _finishActivity( + reference.pointer, _id_finishActivity as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_finishActivityFromChild = _class.instanceMethodId( + r'finishActivityFromChild', + r'(Landroid/app/Activity;I)V', + ); + + static final _finishActivityFromChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public void finishActivityFromChild(android.app.Activity activity, int i) + void finishActivityFromChild( + Activity activity, + int i, + ) { + _finishActivityFromChild( + reference.pointer, + _id_finishActivityFromChild as jni.JMethodIDPtr, + activity.reference.pointer, + i) + .check(); + } + + static final _id_finishAndRemoveTask = _class.instanceMethodId( + r'finishAndRemoveTask', + r'()V', + ); + + static final _finishAndRemoveTask = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void finishAndRemoveTask() + void finishAndRemoveTask() { + _finishAndRemoveTask( + reference.pointer, _id_finishAndRemoveTask as jni.JMethodIDPtr) + .check(); + } + + static final _id_releaseInstance = _class.instanceMethodId( + r'releaseInstance', + r'()Z', + ); + + static final _releaseInstance = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean releaseInstance() + bool releaseInstance() { + return _releaseInstance( + reference.pointer, _id_releaseInstance as jni.JMethodIDPtr) + .boolean; + } + + static final _id_onActivityResult = _class.instanceMethodId( + r'onActivityResult', + r'(IILandroid/content/Intent;)V', + ); + + static final _onActivityResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, $Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, int, ffi.Pointer)>(); + + /// from: protected void onActivityResult(int i, int i1, android.content.Intent intent) + void onActivityResult( + int i, + int i1, + jni.JObject intent, + ) { + _onActivityResult( + reference.pointer, + _id_onActivityResult as jni.JMethodIDPtr, + i, + i1, + intent.reference.pointer) + .check(); + } + + static final _id_onActivityReenter = _class.instanceMethodId( + r'onActivityReenter', + r'(ILandroid/content/Intent;)V', + ); + + static final _onActivityReenter = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: public void onActivityReenter(int i, android.content.Intent intent) + void onActivityReenter( + int i, + jni.JObject intent, + ) { + _onActivityReenter( + reference.pointer, + _id_onActivityReenter as jni.JMethodIDPtr, + i, + intent.reference.pointer) + .check(); + } + + static final _id_createPendingResult = _class.instanceMethodId( + r'createPendingResult', + r'(ILandroid/content/Intent;I)Landroid/app/PendingIntent;', + ); + + static final _createPendingResult = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer, int)>(); + + /// from: public android.app.PendingIntent createPendingResult(int i, android.content.Intent intent, int i1) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject createPendingResult( + int i, + jni.JObject intent, + int i1, + ) { + return _createPendingResult( + reference.pointer, + _id_createPendingResult as jni.JMethodIDPtr, + i, + intent.reference.pointer, + i1) + .object(const jni.JObjectType()); + } + + static final _id_setRequestedOrientation = _class.instanceMethodId( + r'setRequestedOrientation', + r'(I)V', + ); + + static final _setRequestedOrientation = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setRequestedOrientation(int i) + void setRequestedOrientation( + int i, + ) { + _setRequestedOrientation(reference.pointer, + _id_setRequestedOrientation as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_getRequestedOrientation = _class.instanceMethodId( + r'getRequestedOrientation', + r'()I', + ); + + static final _getRequestedOrientation = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int getRequestedOrientation() + int getRequestedOrientation() { + return _getRequestedOrientation( + reference.pointer, _id_getRequestedOrientation as jni.JMethodIDPtr) + .integer; + } + + static final _id_getTaskId = _class.instanceMethodId( + r'getTaskId', + r'()I', + ); + + static final _getTaskId = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int getTaskId() + int getTaskId() { + return _getTaskId(reference.pointer, _id_getTaskId as jni.JMethodIDPtr) + .integer; + } + + static final _id_isTaskRoot = _class.instanceMethodId( + r'isTaskRoot', + r'()Z', + ); + + static final _isTaskRoot = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isTaskRoot() + bool isTaskRoot() { + return _isTaskRoot(reference.pointer, _id_isTaskRoot as jni.JMethodIDPtr) + .boolean; + } + + static final _id_moveTaskToBack = _class.instanceMethodId( + r'moveTaskToBack', + r'(Z)Z', + ); + + static final _moveTaskToBack = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public boolean moveTaskToBack(boolean z) + bool moveTaskToBack( + bool z, + ) { + return _moveTaskToBack(reference.pointer, + _id_moveTaskToBack as jni.JMethodIDPtr, z ? 1 : 0) + .boolean; + } + + static final _id_getLocalClassName = _class.instanceMethodId( + r'getLocalClassName', + r'()Ljava/lang/String;', + ); + + static final _getLocalClassName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getLocalClassName() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getLocalClassName() { + return _getLocalClassName( + reference.pointer, _id_getLocalClassName as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getComponentName = _class.instanceMethodId( + r'getComponentName', + r'()Landroid/content/ComponentName;', + ); + + static final _getComponentName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.content.ComponentName getComponentName() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getComponentName() { + return _getComponentName( + reference.pointer, _id_getComponentName as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getPreferences = _class.instanceMethodId( + r'getPreferences', + r'(I)Landroid/content/SharedPreferences;', + ); + + static final _getPreferences = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public android.content.SharedPreferences getPreferences(int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getPreferences( + int i, + ) { + return _getPreferences( + reference.pointer, _id_getPreferences as jni.JMethodIDPtr, i) + .object(const jni.JObjectType()); + } + + static final _id_isLaunchedFromBubble = _class.instanceMethodId( + r'isLaunchedFromBubble', + r'()Z', + ); + + static final _isLaunchedFromBubble = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isLaunchedFromBubble() + bool isLaunchedFromBubble() { + return _isLaunchedFromBubble( + reference.pointer, _id_isLaunchedFromBubble as jni.JMethodIDPtr) + .boolean; + } + + static final _id_getSystemService = _class.instanceMethodId( + r'getSystemService', + r'(Ljava/lang/String;)Ljava/lang/Object;', + ); + + static final _getSystemService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.lang.Object getSystemService(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSystemService( + jni.JString string, + ) { + return _getSystemService(reference.pointer, + _id_getSystemService as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_setTitle = _class.instanceMethodId( + r'setTitle', + r'(Ljava/lang/CharSequence;)V', + ); + + static final _setTitle = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setTitle(java.lang.CharSequence charSequence) + void setTitle( + jni.JObject charSequence, + ) { + _setTitle(reference.pointer, _id_setTitle as jni.JMethodIDPtr, + charSequence.reference.pointer) + .check(); + } + + static final _id_setTitle1 = _class.instanceMethodId( + r'setTitle', + r'(I)V', + ); + + static final _setTitle1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setTitle(int i) + void setTitle1( + int i, + ) { + _setTitle1(reference.pointer, _id_setTitle1 as jni.JMethodIDPtr, i).check(); + } + + static final _id_setTitleColor = _class.instanceMethodId( + r'setTitleColor', + r'(I)V', + ); + + static final _setTitleColor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setTitleColor(int i) + void setTitleColor( + int i, + ) { + _setTitleColor(reference.pointer, _id_setTitleColor as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_getTitle = _class.instanceMethodId( + r'getTitle', + r'()Ljava/lang/CharSequence;', + ); + + static final _getTitle = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final java.lang.CharSequence getTitle() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getTitle() { + return _getTitle(reference.pointer, _id_getTitle as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getTitleColor = _class.instanceMethodId( + r'getTitleColor', + r'()I', + ); + + static final _getTitleColor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final int getTitleColor() + int getTitleColor() { + return _getTitleColor( + reference.pointer, _id_getTitleColor as jni.JMethodIDPtr) + .integer; + } + + static final _id_onTitleChanged = _class.instanceMethodId( + r'onTitleChanged', + r'(Ljava/lang/CharSequence;I)V', + ); + + static final _onTitleChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: protected void onTitleChanged(java.lang.CharSequence charSequence, int i) + void onTitleChanged( + jni.JObject charSequence, + int i, + ) { + _onTitleChanged(reference.pointer, _id_onTitleChanged as jni.JMethodIDPtr, + charSequence.reference.pointer, i) + .check(); + } + + static final _id_onChildTitleChanged = _class.instanceMethodId( + r'onChildTitleChanged', + r'(Landroid/app/Activity;Ljava/lang/CharSequence;)V', + ); + + static final _onChildTitleChanged = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: protected void onChildTitleChanged(android.app.Activity activity, java.lang.CharSequence charSequence) + void onChildTitleChanged( + Activity activity, + jni.JObject charSequence, + ) { + _onChildTitleChanged( + reference.pointer, + _id_onChildTitleChanged as jni.JMethodIDPtr, + activity.reference.pointer, + charSequence.reference.pointer) + .check(); + } + + static final _id_setTaskDescription = _class.instanceMethodId( + r'setTaskDescription', + r'(Landroid/app/ActivityManager$TaskDescription;)V', + ); + + static final _setTaskDescription = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setTaskDescription(android.app.ActivityManager$TaskDescription taskDescription) + void setTaskDescription( + jni.JObject taskDescription, + ) { + _setTaskDescription( + reference.pointer, + _id_setTaskDescription as jni.JMethodIDPtr, + taskDescription.reference.pointer) + .check(); + } + + static final _id_setProgressBarVisibility = _class.instanceMethodId( + r'setProgressBarVisibility', + r'(Z)V', + ); + + static final _setProgressBarVisibility = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void setProgressBarVisibility(boolean z) + void setProgressBarVisibility( + bool z, + ) { + _setProgressBarVisibility(reference.pointer, + _id_setProgressBarVisibility as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_setProgressBarIndeterminateVisibility = + _class.instanceMethodId( + r'setProgressBarIndeterminateVisibility', + r'(Z)V', + ); + + static final _setProgressBarIndeterminateVisibility = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void setProgressBarIndeterminateVisibility(boolean z) + void setProgressBarIndeterminateVisibility( + bool z, + ) { + _setProgressBarIndeterminateVisibility( + reference.pointer, + _id_setProgressBarIndeterminateVisibility as jni.JMethodIDPtr, + z ? 1 : 0) + .check(); + } + + static final _id_setProgressBarIndeterminate = _class.instanceMethodId( + r'setProgressBarIndeterminate', + r'(Z)V', + ); + + static final _setProgressBarIndeterminate = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void setProgressBarIndeterminate(boolean z) + void setProgressBarIndeterminate( + bool z, + ) { + _setProgressBarIndeterminate(reference.pointer, + _id_setProgressBarIndeterminate as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_setProgress = _class.instanceMethodId( + r'setProgress', + r'(I)V', + ); + + static final _setProgress = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void setProgress(int i) + void setProgress( + int i, + ) { + _setProgress(reference.pointer, _id_setProgress as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_setSecondaryProgress = _class.instanceMethodId( + r'setSecondaryProgress', + r'(I)V', + ); + + static final _setSecondaryProgress = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void setSecondaryProgress(int i) + void setSecondaryProgress( + int i, + ) { + _setSecondaryProgress( + reference.pointer, _id_setSecondaryProgress as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_setVolumeControlStream = _class.instanceMethodId( + r'setVolumeControlStream', + r'(I)V', + ); + + static final _setVolumeControlStream = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final void setVolumeControlStream(int i) + void setVolumeControlStream( + int i, + ) { + _setVolumeControlStream(reference.pointer, + _id_setVolumeControlStream as jni.JMethodIDPtr, i) + .check(); + } + + static final _id_getVolumeControlStream = _class.instanceMethodId( + r'getVolumeControlStream', + r'()I', + ); + + static final _getVolumeControlStream = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final int getVolumeControlStream() + int getVolumeControlStream() { + return _getVolumeControlStream( + reference.pointer, _id_getVolumeControlStream as jni.JMethodIDPtr) + .integer; + } + + static final _id_setMediaController = _class.instanceMethodId( + r'setMediaController', + r'(Landroid/media/session/MediaController;)V', + ); + + static final _setMediaController = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public final void setMediaController(android.media.session.MediaController mediaController) + void setMediaController( + jni.JObject mediaController, + ) { + _setMediaController( + reference.pointer, + _id_setMediaController as jni.JMethodIDPtr, + mediaController.reference.pointer) + .check(); + } + + static final _id_getMediaController = _class.instanceMethodId( + r'getMediaController', + r'()Landroid/media/session/MediaController;', + ); + + static final _getMediaController = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public final android.media.session.MediaController getMediaController() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getMediaController() { + return _getMediaController( + reference.pointer, _id_getMediaController as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_runOnUiThread = _class.instanceMethodId( + r'runOnUiThread', + r'(Ljava/lang/Runnable;)V', + ); + + static final _runOnUiThread = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public final void runOnUiThread(java.lang.Runnable runnable) + void runOnUiThread( + Runnable runnable, + ) { + _runOnUiThread(reference.pointer, _id_runOnUiThread as jni.JMethodIDPtr, + runnable.reference.pointer) + .check(); + } + + static final _id_onCreateView = _class.instanceMethodId( + r'onCreateView', + r'(Ljava/lang/String;Landroid/content/Context;Landroid/util/AttributeSet;)Landroid/view/View;', + ); + + static final _onCreateView = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public android.view.View onCreateView(java.lang.String string, android.content.Context context, android.util.AttributeSet attributeSet) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject onCreateView( + jni.JString string, + Context context, + jni.JObject attributeSet, + ) { + return _onCreateView( + reference.pointer, + _id_onCreateView as jni.JMethodIDPtr, + string.reference.pointer, + context.reference.pointer, + attributeSet.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_onCreateView1 = _class.instanceMethodId( + r'onCreateView', + r'(Landroid/view/View;Ljava/lang/String;Landroid/content/Context;Landroid/util/AttributeSet;)Landroid/view/View;', + ); + + static final _onCreateView1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public android.view.View onCreateView(android.view.View view, java.lang.String string, android.content.Context context, android.util.AttributeSet attributeSet) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject onCreateView1( + jni.JObject view, + jni.JString string, + Context context, + jni.JObject attributeSet, + ) { + return _onCreateView1( + reference.pointer, + _id_onCreateView1 as jni.JMethodIDPtr, + view.reference.pointer, + string.reference.pointer, + context.reference.pointer, + attributeSet.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_dump = _class.instanceMethodId( + r'dump', + r'(Ljava/lang/String;Ljava/io/FileDescriptor;Ljava/io/PrintWriter;[Ljava/lang/String;)V', + ); + + static final _dump = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public void dump(java.lang.String string, java.io.FileDescriptor fileDescriptor, java.io.PrintWriter printWriter, java.lang.String[] strings) + void dump( + jni.JString string, + jni.JObject fileDescriptor, + jni.JObject printWriter, + jni.JArray strings, + ) { + _dump( + reference.pointer, + _id_dump as jni.JMethodIDPtr, + string.reference.pointer, + fileDescriptor.reference.pointer, + printWriter.reference.pointer, + strings.reference.pointer) + .check(); + } + + static final _id_isImmersive = _class.instanceMethodId( + r'isImmersive', + r'()Z', + ); + + static final _isImmersive = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isImmersive() + bool isImmersive() { + return _isImmersive(reference.pointer, _id_isImmersive as jni.JMethodIDPtr) + .boolean; + } + + static final _id_setTranslucent = _class.instanceMethodId( + r'setTranslucent', + r'(Z)Z', + ); + + static final _setTranslucent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public boolean setTranslucent(boolean z) + bool setTranslucent( + bool z, + ) { + return _setTranslucent(reference.pointer, + _id_setTranslucent as jni.JMethodIDPtr, z ? 1 : 0) + .boolean; + } + + static final _id_requestVisibleBehind = _class.instanceMethodId( + r'requestVisibleBehind', + r'(Z)Z', + ); + + static final _requestVisibleBehind = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public boolean requestVisibleBehind(boolean z) + bool requestVisibleBehind( + bool z, + ) { + return _requestVisibleBehind(reference.pointer, + _id_requestVisibleBehind as jni.JMethodIDPtr, z ? 1 : 0) + .boolean; + } + + static final _id_onVisibleBehindCanceled = _class.instanceMethodId( + r'onVisibleBehindCanceled', + r'()V', + ); + + static final _onVisibleBehindCanceled = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onVisibleBehindCanceled() + void onVisibleBehindCanceled() { + _onVisibleBehindCanceled( + reference.pointer, _id_onVisibleBehindCanceled as jni.JMethodIDPtr) + .check(); + } + + static final _id_onEnterAnimationComplete = _class.instanceMethodId( + r'onEnterAnimationComplete', + r'()V', + ); + + static final _onEnterAnimationComplete = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void onEnterAnimationComplete() + void onEnterAnimationComplete() { + _onEnterAnimationComplete( + reference.pointer, _id_onEnterAnimationComplete as jni.JMethodIDPtr) + .check(); + } + + static final _id_setImmersive = _class.instanceMethodId( + r'setImmersive', + r'(Z)V', + ); + + static final _setImmersive = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setImmersive(boolean z) + void setImmersive( + bool z, + ) { + _setImmersive( + reference.pointer, _id_setImmersive as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_setVrModeEnabled = _class.instanceMethodId( + r'setVrModeEnabled', + r'(ZLandroid/content/ComponentName;)V', + ); + + static final _setVrModeEnabled = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + int, ffi.Pointer)>(); + + /// from: public void setVrModeEnabled(boolean z, android.content.ComponentName componentName) + void setVrModeEnabled( + bool z, + jni.JObject componentName, + ) { + _setVrModeEnabled( + reference.pointer, + _id_setVrModeEnabled as jni.JMethodIDPtr, + z ? 1 : 0, + componentName.reference.pointer) + .check(); + } + + static final _id_startActionMode = _class.instanceMethodId( + r'startActionMode', + r'(Landroid/view/ActionMode$Callback;)Landroid/view/ActionMode;', + ); + + static final _startActionMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.view.ActionMode startActionMode(android.view.ActionMode$Callback callback) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject startActionMode( + jni.JObject callback, + ) { + return _startActionMode(reference.pointer, + _id_startActionMode as jni.JMethodIDPtr, callback.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_startActionMode1 = _class.instanceMethodId( + r'startActionMode', + r'(Landroid/view/ActionMode$Callback;I)Landroid/view/ActionMode;', + ); + + static final _startActionMode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public android.view.ActionMode startActionMode(android.view.ActionMode$Callback callback, int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject startActionMode1( + jni.JObject callback, + int i, + ) { + return _startActionMode1( + reference.pointer, + _id_startActionMode1 as jni.JMethodIDPtr, + callback.reference.pointer, + i) + .object(const jni.JObjectType()); + } + + static final _id_onWindowStartingActionMode = _class.instanceMethodId( + r'onWindowStartingActionMode', + r'(Landroid/view/ActionMode$Callback;)Landroid/view/ActionMode;', + ); + + static final _onWindowStartingActionMode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.view.ActionMode onWindowStartingActionMode(android.view.ActionMode$Callback callback) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject onWindowStartingActionMode( + jni.JObject callback, + ) { + return _onWindowStartingActionMode( + reference.pointer, + _id_onWindowStartingActionMode as jni.JMethodIDPtr, + callback.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_onWindowStartingActionMode1 = _class.instanceMethodId( + r'onWindowStartingActionMode', + r'(Landroid/view/ActionMode$Callback;I)Landroid/view/ActionMode;', + ); + + static final _onWindowStartingActionMode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public android.view.ActionMode onWindowStartingActionMode(android.view.ActionMode$Callback callback, int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject onWindowStartingActionMode1( + jni.JObject callback, + int i, + ) { + return _onWindowStartingActionMode1( + reference.pointer, + _id_onWindowStartingActionMode1 as jni.JMethodIDPtr, + callback.reference.pointer, + i) + .object(const jni.JObjectType()); + } + + static final _id_onActionModeStarted = _class.instanceMethodId( + r'onActionModeStarted', + r'(Landroid/view/ActionMode;)V', + ); + + static final _onActionModeStarted = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onActionModeStarted(android.view.ActionMode actionMode) + void onActionModeStarted( + jni.JObject actionMode, + ) { + _onActionModeStarted( + reference.pointer, + _id_onActionModeStarted as jni.JMethodIDPtr, + actionMode.reference.pointer) + .check(); + } + + static final _id_onActionModeFinished = _class.instanceMethodId( + r'onActionModeFinished', + r'(Landroid/view/ActionMode;)V', + ); + + static final _onActionModeFinished = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void onActionModeFinished(android.view.ActionMode actionMode) + void onActionModeFinished( + jni.JObject actionMode, + ) { + _onActionModeFinished( + reference.pointer, + _id_onActionModeFinished as jni.JMethodIDPtr, + actionMode.reference.pointer) + .check(); + } + + static final _id_shouldUpRecreateTask = _class.instanceMethodId( + r'shouldUpRecreateTask', + r'(Landroid/content/Intent;)Z', + ); + + static final _shouldUpRecreateTask = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean shouldUpRecreateTask(android.content.Intent intent) + bool shouldUpRecreateTask( + jni.JObject intent, + ) { + return _shouldUpRecreateTask( + reference.pointer, + _id_shouldUpRecreateTask as jni.JMethodIDPtr, + intent.reference.pointer) + .boolean; + } + + static final _id_navigateUpTo = _class.instanceMethodId( + r'navigateUpTo', + r'(Landroid/content/Intent;)Z', + ); + + static final _navigateUpTo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean navigateUpTo(android.content.Intent intent) + bool navigateUpTo( + jni.JObject intent, + ) { + return _navigateUpTo(reference.pointer, + _id_navigateUpTo as jni.JMethodIDPtr, intent.reference.pointer) + .boolean; + } + + static final _id_navigateUpToFromChild = _class.instanceMethodId( + r'navigateUpToFromChild', + r'(Landroid/app/Activity;Landroid/content/Intent;)Z', + ); + + static final _navigateUpToFromChild = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public boolean navigateUpToFromChild(android.app.Activity activity, android.content.Intent intent) + bool navigateUpToFromChild( + Activity activity, + jni.JObject intent, + ) { + return _navigateUpToFromChild( + reference.pointer, + _id_navigateUpToFromChild as jni.JMethodIDPtr, + activity.reference.pointer, + intent.reference.pointer) + .boolean; + } + + static final _id_getParentActivityIntent = _class.instanceMethodId( + r'getParentActivityIntent', + r'()Landroid/content/Intent;', + ); + + static final _getParentActivityIntent = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.content.Intent getParentActivityIntent() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getParentActivityIntent() { + return _getParentActivityIntent( + reference.pointer, _id_getParentActivityIntent as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_setEnterSharedElementCallback = _class.instanceMethodId( + r'setEnterSharedElementCallback', + r'(Landroid/app/SharedElementCallback;)V', + ); + + static final _setEnterSharedElementCallback = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setEnterSharedElementCallback(android.app.SharedElementCallback sharedElementCallback) + void setEnterSharedElementCallback( + jni.JObject sharedElementCallback, + ) { + _setEnterSharedElementCallback( + reference.pointer, + _id_setEnterSharedElementCallback as jni.JMethodIDPtr, + sharedElementCallback.reference.pointer) + .check(); + } + + static final _id_setExitSharedElementCallback = _class.instanceMethodId( + r'setExitSharedElementCallback', + r'(Landroid/app/SharedElementCallback;)V', + ); + + static final _setExitSharedElementCallback = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setExitSharedElementCallback(android.app.SharedElementCallback sharedElementCallback) + void setExitSharedElementCallback( + jni.JObject sharedElementCallback, + ) { + _setExitSharedElementCallback( + reference.pointer, + _id_setExitSharedElementCallback as jni.JMethodIDPtr, + sharedElementCallback.reference.pointer) + .check(); + } + + static final _id_postponeEnterTransition = _class.instanceMethodId( + r'postponeEnterTransition', + r'()V', + ); + + static final _postponeEnterTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void postponeEnterTransition() + void postponeEnterTransition() { + _postponeEnterTransition( + reference.pointer, _id_postponeEnterTransition as jni.JMethodIDPtr) + .check(); + } + + static final _id_startPostponedEnterTransition = _class.instanceMethodId( + r'startPostponedEnterTransition', + r'()V', + ); + + static final _startPostponedEnterTransition = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void startPostponedEnterTransition() + void startPostponedEnterTransition() { + _startPostponedEnterTransition(reference.pointer, + _id_startPostponedEnterTransition as jni.JMethodIDPtr) + .check(); + } + + static final _id_requestDragAndDropPermissions = _class.instanceMethodId( + r'requestDragAndDropPermissions', + r'(Landroid/view/DragEvent;)Landroid/view/DragAndDropPermissions;', + ); + + static final _requestDragAndDropPermissions = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.view.DragAndDropPermissions requestDragAndDropPermissions(android.view.DragEvent dragEvent) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject requestDragAndDropPermissions( + jni.JObject dragEvent, + ) { + return _requestDragAndDropPermissions( + reference.pointer, + _id_requestDragAndDropPermissions as jni.JMethodIDPtr, + dragEvent.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_startLockTask = _class.instanceMethodId( + r'startLockTask', + r'()V', + ); + + static final _startLockTask = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void startLockTask() + void startLockTask() { + _startLockTask(reference.pointer, _id_startLockTask as jni.JMethodIDPtr) + .check(); + } + + static final _id_stopLockTask = _class.instanceMethodId( + r'stopLockTask', + r'()V', + ); + + static final _stopLockTask = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void stopLockTask() + void stopLockTask() { + _stopLockTask(reference.pointer, _id_stopLockTask as jni.JMethodIDPtr) + .check(); + } + + static final _id_showLockTaskEscapeMessage = _class.instanceMethodId( + r'showLockTaskEscapeMessage', + r'()V', + ); + + static final _showLockTaskEscapeMessage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void showLockTaskEscapeMessage() + void showLockTaskEscapeMessage() { + _showLockTaskEscapeMessage(reference.pointer, + _id_showLockTaskEscapeMessage as jni.JMethodIDPtr) + .check(); + } + + static final _id_setRecentsScreenshotEnabled = _class.instanceMethodId( + r'setRecentsScreenshotEnabled', + r'(Z)V', + ); + + static final _setRecentsScreenshotEnabled = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setRecentsScreenshotEnabled(boolean z) + void setRecentsScreenshotEnabled( + bool z, + ) { + _setRecentsScreenshotEnabled(reference.pointer, + _id_setRecentsScreenshotEnabled as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_setShowWhenLocked = _class.instanceMethodId( + r'setShowWhenLocked', + r'(Z)V', + ); + + static final _setShowWhenLocked = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setShowWhenLocked(boolean z) + void setShowWhenLocked( + bool z, + ) { + _setShowWhenLocked(reference.pointer, + _id_setShowWhenLocked as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_setInheritShowWhenLocked = _class.instanceMethodId( + r'setInheritShowWhenLocked', + r'(Z)V', + ); + + static final _setInheritShowWhenLocked = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setInheritShowWhenLocked(boolean z) + void setInheritShowWhenLocked( + bool z, + ) { + _setInheritShowWhenLocked(reference.pointer, + _id_setInheritShowWhenLocked as jni.JMethodIDPtr, z ? 1 : 0) + .check(); + } + + static final _id_setTurnScreenOn = _class.instanceMethodId( + r'setTurnScreenOn', + r'(Z)V', + ); + + static final _setTurnScreenOn = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void setTurnScreenOn(boolean z) + void setTurnScreenOn( + bool z, + ) { + _setTurnScreenOn(reference.pointer, _id_setTurnScreenOn as jni.JMethodIDPtr, + z ? 1 : 0) + .check(); + } + + static final _id_getOnBackInvokedDispatcher = _class.instanceMethodId( + r'getOnBackInvokedDispatcher', + r'()Landroid/window/OnBackInvokedDispatcher;', + ); + + static final _getOnBackInvokedDispatcher = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.window.OnBackInvokedDispatcher getOnBackInvokedDispatcher() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getOnBackInvokedDispatcher() { + return _getOnBackInvokedDispatcher(reference.pointer, + _id_getOnBackInvokedDispatcher as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_registerScreenCaptureCallback = _class.instanceMethodId( + r'registerScreenCaptureCallback', + r'(Ljava/util/concurrent/Executor;Landroid/app/Activity$ScreenCaptureCallback;)V', + ); + + static final _registerScreenCaptureCallback = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void registerScreenCaptureCallback(java.util.concurrent.Executor executor, android.app.Activity$ScreenCaptureCallback screenCaptureCallback) + void registerScreenCaptureCallback( + jni.JObject executor, + Activity_ScreenCaptureCallback screenCaptureCallback, + ) { + _registerScreenCaptureCallback( + reference.pointer, + _id_registerScreenCaptureCallback as jni.JMethodIDPtr, + executor.reference.pointer, + screenCaptureCallback.reference.pointer) + .check(); + } + + static final _id_unregisterScreenCaptureCallback = _class.instanceMethodId( + r'unregisterScreenCaptureCallback', + r'(Landroid/app/Activity$ScreenCaptureCallback;)V', + ); + + static final _unregisterScreenCaptureCallback = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void unregisterScreenCaptureCallback(android.app.Activity$ScreenCaptureCallback screenCaptureCallback) + void unregisterScreenCaptureCallback( + Activity_ScreenCaptureCallback screenCaptureCallback, + ) { + _unregisterScreenCaptureCallback( + reference.pointer, + _id_unregisterScreenCaptureCallback as jni.JMethodIDPtr, + screenCaptureCallback.reference.pointer) + .check(); + } +} + +final class $ActivityType extends jni.JObjType { + const $ActivityType(); + + @override + String get signature => r'Landroid/app/Activity;'; + + @override + Activity fromReference(jni.JReference reference) => + Activity.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($ActivityType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($ActivityType) && other is $ActivityType; + } +} + +/// from: android.content.Context$BindServiceFlags +class Context_BindServiceFlags extends jni.JObject { + @override + late final jni.JObjType $type = type; + + Context_BindServiceFlags.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r'android/content/Context$BindServiceFlags'); + + /// The type which includes information such as the signature of this class. + static const type = $Context_BindServiceFlagsType(); + static final _id_of = _class.staticMethodId( + r'of', + r'(J)Landroid/content/Context$BindServiceFlags;', + ); + + static final _of = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.VarArgs<(ffi.Int64,)>)>>( + 'globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: static public android.content.Context$BindServiceFlags of(long j) + /// The returned object must be released after use, by calling the [release] method. + static Context_BindServiceFlags of( + int j, + ) { + return _of(_class.reference.pointer, _id_of as jni.JMethodIDPtr, j) + .object(const $Context_BindServiceFlagsType()); + } +} + +final class $Context_BindServiceFlagsType + extends jni.JObjType { + const $Context_BindServiceFlagsType(); + + @override + String get signature => r'Landroid/content/Context$BindServiceFlags;'; + + @override + Context_BindServiceFlags fromReference(jni.JReference reference) => + Context_BindServiceFlags.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($Context_BindServiceFlagsType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($Context_BindServiceFlagsType) && + other is $Context_BindServiceFlagsType; + } +} + +/// from: android.content.Context +class Context extends jni.JObject { + @override + late final jni.JObjType $type = type; + + Context.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r'android/content/Context'); + + /// The type which includes information such as the signature of this class. + static const type = $ContextType(); + static final _id_ACCESSIBILITY_SERVICE = _class.staticFieldId( + r'ACCESSIBILITY_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String ACCESSIBILITY_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get ACCESSIBILITY_SERVICE => + _id_ACCESSIBILITY_SERVICE.get(_class, const jni.JStringType()); + + static final _id_ACCOUNT_SERVICE = _class.staticFieldId( + r'ACCOUNT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String ACCOUNT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get ACCOUNT_SERVICE => + _id_ACCOUNT_SERVICE.get(_class, const jni.JStringType()); + + static final _id_ACTIVITY_SERVICE = _class.staticFieldId( + r'ACTIVITY_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String ACTIVITY_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get ACTIVITY_SERVICE => + _id_ACTIVITY_SERVICE.get(_class, const jni.JStringType()); + + static final _id_ALARM_SERVICE = _class.staticFieldId( + r'ALARM_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String ALARM_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get ALARM_SERVICE => + _id_ALARM_SERVICE.get(_class, const jni.JStringType()); + + static final _id_APPWIDGET_SERVICE = _class.staticFieldId( + r'APPWIDGET_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String APPWIDGET_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get APPWIDGET_SERVICE => + _id_APPWIDGET_SERVICE.get(_class, const jni.JStringType()); + + static final _id_APP_OPS_SERVICE = _class.staticFieldId( + r'APP_OPS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String APP_OPS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get APP_OPS_SERVICE => + _id_APP_OPS_SERVICE.get(_class, const jni.JStringType()); + + static final _id_APP_SEARCH_SERVICE = _class.staticFieldId( + r'APP_SEARCH_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String APP_SEARCH_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get APP_SEARCH_SERVICE => + _id_APP_SEARCH_SERVICE.get(_class, const jni.JStringType()); + + static final _id_AUDIO_SERVICE = _class.staticFieldId( + r'AUDIO_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String AUDIO_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get AUDIO_SERVICE => + _id_AUDIO_SERVICE.get(_class, const jni.JStringType()); + + static final _id_BATTERY_SERVICE = _class.staticFieldId( + r'BATTERY_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String BATTERY_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get BATTERY_SERVICE => + _id_BATTERY_SERVICE.get(_class, const jni.JStringType()); + + /// from: static public final int BIND_ABOVE_CLIENT + static const BIND_ABOVE_CLIENT = 8; + + /// from: static public final int BIND_ADJUST_WITH_ACTIVITY + static const BIND_ADJUST_WITH_ACTIVITY = 128; + + /// from: static public final int BIND_ALLOW_ACTIVITY_STARTS + static const BIND_ALLOW_ACTIVITY_STARTS = 512; + + /// from: static public final int BIND_ALLOW_OOM_MANAGEMENT + static const BIND_ALLOW_OOM_MANAGEMENT = 16; + + /// from: static public final int BIND_AUTO_CREATE + static const BIND_AUTO_CREATE = 1; + + /// from: static public final int BIND_DEBUG_UNBIND + static const BIND_DEBUG_UNBIND = 2; + + /// from: static public final int BIND_EXTERNAL_SERVICE + static const BIND_EXTERNAL_SERVICE = -2147483648; + + /// from: static public final long BIND_EXTERNAL_SERVICE_LONG + static const BIND_EXTERNAL_SERVICE_LONG = 4611686018427387904; + + /// from: static public final int BIND_IMPORTANT + static const BIND_IMPORTANT = 64; + + /// from: static public final int BIND_INCLUDE_CAPABILITIES + static const BIND_INCLUDE_CAPABILITIES = 4096; + + /// from: static public final int BIND_NOT_FOREGROUND + static const BIND_NOT_FOREGROUND = 4; + + /// from: static public final int BIND_NOT_PERCEPTIBLE + static const BIND_NOT_PERCEPTIBLE = 256; + + /// from: static public final int BIND_SHARED_ISOLATED_PROCESS + static const BIND_SHARED_ISOLATED_PROCESS = 8192; + + /// from: static public final int BIND_WAIVE_PRIORITY + static const BIND_WAIVE_PRIORITY = 32; + static final _id_BIOMETRIC_SERVICE = _class.staticFieldId( + r'BIOMETRIC_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String BIOMETRIC_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get BIOMETRIC_SERVICE => + _id_BIOMETRIC_SERVICE.get(_class, const jni.JStringType()); + + static final _id_BLOB_STORE_SERVICE = _class.staticFieldId( + r'BLOB_STORE_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String BLOB_STORE_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get BLOB_STORE_SERVICE => + _id_BLOB_STORE_SERVICE.get(_class, const jni.JStringType()); + + static final _id_BLUETOOTH_SERVICE = _class.staticFieldId( + r'BLUETOOTH_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String BLUETOOTH_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get BLUETOOTH_SERVICE => + _id_BLUETOOTH_SERVICE.get(_class, const jni.JStringType()); + + static final _id_BUGREPORT_SERVICE = _class.staticFieldId( + r'BUGREPORT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String BUGREPORT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get BUGREPORT_SERVICE => + _id_BUGREPORT_SERVICE.get(_class, const jni.JStringType()); + + static final _id_CAMERA_SERVICE = _class.staticFieldId( + r'CAMERA_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String CAMERA_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get CAMERA_SERVICE => + _id_CAMERA_SERVICE.get(_class, const jni.JStringType()); + + static final _id_CAPTIONING_SERVICE = _class.staticFieldId( + r'CAPTIONING_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String CAPTIONING_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get CAPTIONING_SERVICE => + _id_CAPTIONING_SERVICE.get(_class, const jni.JStringType()); + + static final _id_CARRIER_CONFIG_SERVICE = _class.staticFieldId( + r'CARRIER_CONFIG_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String CARRIER_CONFIG_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get CARRIER_CONFIG_SERVICE => + _id_CARRIER_CONFIG_SERVICE.get(_class, const jni.JStringType()); + + static final _id_CLIPBOARD_SERVICE = _class.staticFieldId( + r'CLIPBOARD_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String CLIPBOARD_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get CLIPBOARD_SERVICE => + _id_CLIPBOARD_SERVICE.get(_class, const jni.JStringType()); + + static final _id_COMPANION_DEVICE_SERVICE = _class.staticFieldId( + r'COMPANION_DEVICE_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String COMPANION_DEVICE_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get COMPANION_DEVICE_SERVICE => + _id_COMPANION_DEVICE_SERVICE.get(_class, const jni.JStringType()); + + static final _id_CONNECTIVITY_DIAGNOSTICS_SERVICE = _class.staticFieldId( + r'CONNECTIVITY_DIAGNOSTICS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String CONNECTIVITY_DIAGNOSTICS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get CONNECTIVITY_DIAGNOSTICS_SERVICE => + _id_CONNECTIVITY_DIAGNOSTICS_SERVICE.get(_class, const jni.JStringType()); + + static final _id_CONNECTIVITY_SERVICE = _class.staticFieldId( + r'CONNECTIVITY_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String CONNECTIVITY_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get CONNECTIVITY_SERVICE => + _id_CONNECTIVITY_SERVICE.get(_class, const jni.JStringType()); + + static final _id_CONSUMER_IR_SERVICE = _class.staticFieldId( + r'CONSUMER_IR_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String CONSUMER_IR_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get CONSUMER_IR_SERVICE => + _id_CONSUMER_IR_SERVICE.get(_class, const jni.JStringType()); + + /// from: static public final int CONTEXT_IGNORE_SECURITY + static const CONTEXT_IGNORE_SECURITY = 2; + + /// from: static public final int CONTEXT_INCLUDE_CODE + static const CONTEXT_INCLUDE_CODE = 1; + + /// from: static public final int CONTEXT_RESTRICTED + static const CONTEXT_RESTRICTED = 4; + static final _id_CREDENTIAL_SERVICE = _class.staticFieldId( + r'CREDENTIAL_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String CREDENTIAL_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get CREDENTIAL_SERVICE => + _id_CREDENTIAL_SERVICE.get(_class, const jni.JStringType()); + + static final _id_CROSS_PROFILE_APPS_SERVICE = _class.staticFieldId( + r'CROSS_PROFILE_APPS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String CROSS_PROFILE_APPS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get CROSS_PROFILE_APPS_SERVICE => + _id_CROSS_PROFILE_APPS_SERVICE.get(_class, const jni.JStringType()); + + /// from: static public final int DEVICE_ID_DEFAULT + static const DEVICE_ID_DEFAULT = 0; + + /// from: static public final int DEVICE_ID_INVALID + static const DEVICE_ID_INVALID = -1; + static final _id_DEVICE_LOCK_SERVICE = _class.staticFieldId( + r'DEVICE_LOCK_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String DEVICE_LOCK_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get DEVICE_LOCK_SERVICE => + _id_DEVICE_LOCK_SERVICE.get(_class, const jni.JStringType()); + + static final _id_DEVICE_POLICY_SERVICE = _class.staticFieldId( + r'DEVICE_POLICY_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String DEVICE_POLICY_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get DEVICE_POLICY_SERVICE => + _id_DEVICE_POLICY_SERVICE.get(_class, const jni.JStringType()); + + static final _id_DISPLAY_HASH_SERVICE = _class.staticFieldId( + r'DISPLAY_HASH_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String DISPLAY_HASH_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get DISPLAY_HASH_SERVICE => + _id_DISPLAY_HASH_SERVICE.get(_class, const jni.JStringType()); + + static final _id_DISPLAY_SERVICE = _class.staticFieldId( + r'DISPLAY_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String DISPLAY_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get DISPLAY_SERVICE => + _id_DISPLAY_SERVICE.get(_class, const jni.JStringType()); + + static final _id_DOMAIN_VERIFICATION_SERVICE = _class.staticFieldId( + r'DOMAIN_VERIFICATION_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String DOMAIN_VERIFICATION_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get DOMAIN_VERIFICATION_SERVICE => + _id_DOMAIN_VERIFICATION_SERVICE.get(_class, const jni.JStringType()); + + static final _id_DOWNLOAD_SERVICE = _class.staticFieldId( + r'DOWNLOAD_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String DOWNLOAD_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get DOWNLOAD_SERVICE => + _id_DOWNLOAD_SERVICE.get(_class, const jni.JStringType()); + + static final _id_DROPBOX_SERVICE = _class.staticFieldId( + r'DROPBOX_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String DROPBOX_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get DROPBOX_SERVICE => + _id_DROPBOX_SERVICE.get(_class, const jni.JStringType()); + + static final _id_EUICC_SERVICE = _class.staticFieldId( + r'EUICC_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String EUICC_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get EUICC_SERVICE => + _id_EUICC_SERVICE.get(_class, const jni.JStringType()); + + static final _id_FILE_INTEGRITY_SERVICE = _class.staticFieldId( + r'FILE_INTEGRITY_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String FILE_INTEGRITY_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get FILE_INTEGRITY_SERVICE => + _id_FILE_INTEGRITY_SERVICE.get(_class, const jni.JStringType()); + + static final _id_FINGERPRINT_SERVICE = _class.staticFieldId( + r'FINGERPRINT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String FINGERPRINT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get FINGERPRINT_SERVICE => + _id_FINGERPRINT_SERVICE.get(_class, const jni.JStringType()); + + static final _id_GAME_SERVICE = _class.staticFieldId( + r'GAME_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String GAME_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get GAME_SERVICE => + _id_GAME_SERVICE.get(_class, const jni.JStringType()); + + static final _id_GRAMMATICAL_INFLECTION_SERVICE = _class.staticFieldId( + r'GRAMMATICAL_INFLECTION_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String GRAMMATICAL_INFLECTION_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get GRAMMATICAL_INFLECTION_SERVICE => + _id_GRAMMATICAL_INFLECTION_SERVICE.get(_class, const jni.JStringType()); + + static final _id_HARDWARE_PROPERTIES_SERVICE = _class.staticFieldId( + r'HARDWARE_PROPERTIES_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String HARDWARE_PROPERTIES_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get HARDWARE_PROPERTIES_SERVICE => + _id_HARDWARE_PROPERTIES_SERVICE.get(_class, const jni.JStringType()); + + static final _id_HEALTHCONNECT_SERVICE = _class.staticFieldId( + r'HEALTHCONNECT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String HEALTHCONNECT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get HEALTHCONNECT_SERVICE => + _id_HEALTHCONNECT_SERVICE.get(_class, const jni.JStringType()); + + static final _id_INPUT_METHOD_SERVICE = _class.staticFieldId( + r'INPUT_METHOD_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String INPUT_METHOD_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get INPUT_METHOD_SERVICE => + _id_INPUT_METHOD_SERVICE.get(_class, const jni.JStringType()); + + static final _id_INPUT_SERVICE = _class.staticFieldId( + r'INPUT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String INPUT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get INPUT_SERVICE => + _id_INPUT_SERVICE.get(_class, const jni.JStringType()); + + static final _id_IPSEC_SERVICE = _class.staticFieldId( + r'IPSEC_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String IPSEC_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get IPSEC_SERVICE => + _id_IPSEC_SERVICE.get(_class, const jni.JStringType()); + + static final _id_JOB_SCHEDULER_SERVICE = _class.staticFieldId( + r'JOB_SCHEDULER_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String JOB_SCHEDULER_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get JOB_SCHEDULER_SERVICE => + _id_JOB_SCHEDULER_SERVICE.get(_class, const jni.JStringType()); + + static final _id_KEYGUARD_SERVICE = _class.staticFieldId( + r'KEYGUARD_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String KEYGUARD_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get KEYGUARD_SERVICE => + _id_KEYGUARD_SERVICE.get(_class, const jni.JStringType()); + + static final _id_LAUNCHER_APPS_SERVICE = _class.staticFieldId( + r'LAUNCHER_APPS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String LAUNCHER_APPS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get LAUNCHER_APPS_SERVICE => + _id_LAUNCHER_APPS_SERVICE.get(_class, const jni.JStringType()); + + static final _id_LAYOUT_INFLATER_SERVICE = _class.staticFieldId( + r'LAYOUT_INFLATER_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String LAYOUT_INFLATER_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get LAYOUT_INFLATER_SERVICE => + _id_LAYOUT_INFLATER_SERVICE.get(_class, const jni.JStringType()); + + static final _id_LOCALE_SERVICE = _class.staticFieldId( + r'LOCALE_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String LOCALE_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get LOCALE_SERVICE => + _id_LOCALE_SERVICE.get(_class, const jni.JStringType()); + + static final _id_LOCATION_SERVICE = _class.staticFieldId( + r'LOCATION_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String LOCATION_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get LOCATION_SERVICE => + _id_LOCATION_SERVICE.get(_class, const jni.JStringType()); + + static final _id_MEDIA_COMMUNICATION_SERVICE = _class.staticFieldId( + r'MEDIA_COMMUNICATION_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String MEDIA_COMMUNICATION_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get MEDIA_COMMUNICATION_SERVICE => + _id_MEDIA_COMMUNICATION_SERVICE.get(_class, const jni.JStringType()); + + static final _id_MEDIA_METRICS_SERVICE = _class.staticFieldId( + r'MEDIA_METRICS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String MEDIA_METRICS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get MEDIA_METRICS_SERVICE => + _id_MEDIA_METRICS_SERVICE.get(_class, const jni.JStringType()); + + static final _id_MEDIA_PROJECTION_SERVICE = _class.staticFieldId( + r'MEDIA_PROJECTION_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String MEDIA_PROJECTION_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get MEDIA_PROJECTION_SERVICE => + _id_MEDIA_PROJECTION_SERVICE.get(_class, const jni.JStringType()); + + static final _id_MEDIA_ROUTER_SERVICE = _class.staticFieldId( + r'MEDIA_ROUTER_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String MEDIA_ROUTER_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get MEDIA_ROUTER_SERVICE => + _id_MEDIA_ROUTER_SERVICE.get(_class, const jni.JStringType()); + + static final _id_MEDIA_SESSION_SERVICE = _class.staticFieldId( + r'MEDIA_SESSION_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String MEDIA_SESSION_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get MEDIA_SESSION_SERVICE => + _id_MEDIA_SESSION_SERVICE.get(_class, const jni.JStringType()); + + static final _id_MIDI_SERVICE = _class.staticFieldId( + r'MIDI_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String MIDI_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get MIDI_SERVICE => + _id_MIDI_SERVICE.get(_class, const jni.JStringType()); + + /// from: static public final int MODE_APPEND + static const MODE_APPEND = 32768; + + /// from: static public final int MODE_ENABLE_WRITE_AHEAD_LOGGING + static const MODE_ENABLE_WRITE_AHEAD_LOGGING = 8; + + /// from: static public final int MODE_MULTI_PROCESS + static const MODE_MULTI_PROCESS = 4; + + /// from: static public final int MODE_NO_LOCALIZED_COLLATORS + static const MODE_NO_LOCALIZED_COLLATORS = 16; + + /// from: static public final int MODE_PRIVATE + static const MODE_PRIVATE = 0; + + /// from: static public final int MODE_WORLD_READABLE + static const MODE_WORLD_READABLE = 1; + + /// from: static public final int MODE_WORLD_WRITEABLE + static const MODE_WORLD_WRITEABLE = 2; + static final _id_NETWORK_STATS_SERVICE = _class.staticFieldId( + r'NETWORK_STATS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String NETWORK_STATS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get NETWORK_STATS_SERVICE => + _id_NETWORK_STATS_SERVICE.get(_class, const jni.JStringType()); + + static final _id_NFC_SERVICE = _class.staticFieldId( + r'NFC_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String NFC_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get NFC_SERVICE => + _id_NFC_SERVICE.get(_class, const jni.JStringType()); + + static final _id_NOTIFICATION_SERVICE = _class.staticFieldId( + r'NOTIFICATION_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String NOTIFICATION_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get NOTIFICATION_SERVICE => + _id_NOTIFICATION_SERVICE.get(_class, const jni.JStringType()); + + static final _id_NSD_SERVICE = _class.staticFieldId( + r'NSD_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String NSD_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get NSD_SERVICE => + _id_NSD_SERVICE.get(_class, const jni.JStringType()); + + static final _id_OVERLAY_SERVICE = _class.staticFieldId( + r'OVERLAY_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String OVERLAY_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get OVERLAY_SERVICE => + _id_OVERLAY_SERVICE.get(_class, const jni.JStringType()); + + static final _id_PEOPLE_SERVICE = _class.staticFieldId( + r'PEOPLE_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String PEOPLE_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get PEOPLE_SERVICE => + _id_PEOPLE_SERVICE.get(_class, const jni.JStringType()); + + static final _id_PERFORMANCE_HINT_SERVICE = _class.staticFieldId( + r'PERFORMANCE_HINT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String PERFORMANCE_HINT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get PERFORMANCE_HINT_SERVICE => + _id_PERFORMANCE_HINT_SERVICE.get(_class, const jni.JStringType()); + + static final _id_POWER_SERVICE = _class.staticFieldId( + r'POWER_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String POWER_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get POWER_SERVICE => + _id_POWER_SERVICE.get(_class, const jni.JStringType()); + + static final _id_PRINT_SERVICE = _class.staticFieldId( + r'PRINT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String PRINT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get PRINT_SERVICE => + _id_PRINT_SERVICE.get(_class, const jni.JStringType()); + + /// from: static public final int RECEIVER_EXPORTED + static const RECEIVER_EXPORTED = 2; + + /// from: static public final int RECEIVER_NOT_EXPORTED + static const RECEIVER_NOT_EXPORTED = 4; + + /// from: static public final int RECEIVER_VISIBLE_TO_INSTANT_APPS + static const RECEIVER_VISIBLE_TO_INSTANT_APPS = 1; + static final _id_RESTRICTIONS_SERVICE = _class.staticFieldId( + r'RESTRICTIONS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String RESTRICTIONS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get RESTRICTIONS_SERVICE => + _id_RESTRICTIONS_SERVICE.get(_class, const jni.JStringType()); + + static final _id_ROLE_SERVICE = _class.staticFieldId( + r'ROLE_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String ROLE_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get ROLE_SERVICE => + _id_ROLE_SERVICE.get(_class, const jni.JStringType()); + + static final _id_SEARCH_SERVICE = _class.staticFieldId( + r'SEARCH_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String SEARCH_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get SEARCH_SERVICE => + _id_SEARCH_SERVICE.get(_class, const jni.JStringType()); + + static final _id_SENSOR_SERVICE = _class.staticFieldId( + r'SENSOR_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String SENSOR_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get SENSOR_SERVICE => + _id_SENSOR_SERVICE.get(_class, const jni.JStringType()); + + static final _id_SHORTCUT_SERVICE = _class.staticFieldId( + r'SHORTCUT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String SHORTCUT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get SHORTCUT_SERVICE => + _id_SHORTCUT_SERVICE.get(_class, const jni.JStringType()); + + static final _id_STATUS_BAR_SERVICE = _class.staticFieldId( + r'STATUS_BAR_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String STATUS_BAR_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get STATUS_BAR_SERVICE => + _id_STATUS_BAR_SERVICE.get(_class, const jni.JStringType()); + + static final _id_STORAGE_SERVICE = _class.staticFieldId( + r'STORAGE_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String STORAGE_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get STORAGE_SERVICE => + _id_STORAGE_SERVICE.get(_class, const jni.JStringType()); + + static final _id_STORAGE_STATS_SERVICE = _class.staticFieldId( + r'STORAGE_STATS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String STORAGE_STATS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get STORAGE_STATS_SERVICE => + _id_STORAGE_STATS_SERVICE.get(_class, const jni.JStringType()); + + static final _id_SYSTEM_HEALTH_SERVICE = _class.staticFieldId( + r'SYSTEM_HEALTH_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String SYSTEM_HEALTH_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get SYSTEM_HEALTH_SERVICE => + _id_SYSTEM_HEALTH_SERVICE.get(_class, const jni.JStringType()); + + static final _id_TELECOM_SERVICE = _class.staticFieldId( + r'TELECOM_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String TELECOM_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get TELECOM_SERVICE => + _id_TELECOM_SERVICE.get(_class, const jni.JStringType()); + + static final _id_TELEPHONY_IMS_SERVICE = _class.staticFieldId( + r'TELEPHONY_IMS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String TELEPHONY_IMS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get TELEPHONY_IMS_SERVICE => + _id_TELEPHONY_IMS_SERVICE.get(_class, const jni.JStringType()); + + static final _id_TELEPHONY_SERVICE = _class.staticFieldId( + r'TELEPHONY_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String TELEPHONY_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get TELEPHONY_SERVICE => + _id_TELEPHONY_SERVICE.get(_class, const jni.JStringType()); + + static final _id_TELEPHONY_SUBSCRIPTION_SERVICE = _class.staticFieldId( + r'TELEPHONY_SUBSCRIPTION_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String TELEPHONY_SUBSCRIPTION_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get TELEPHONY_SUBSCRIPTION_SERVICE => + _id_TELEPHONY_SUBSCRIPTION_SERVICE.get(_class, const jni.JStringType()); + + static final _id_TEXT_CLASSIFICATION_SERVICE = _class.staticFieldId( + r'TEXT_CLASSIFICATION_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String TEXT_CLASSIFICATION_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get TEXT_CLASSIFICATION_SERVICE => + _id_TEXT_CLASSIFICATION_SERVICE.get(_class, const jni.JStringType()); + + static final _id_TEXT_SERVICES_MANAGER_SERVICE = _class.staticFieldId( + r'TEXT_SERVICES_MANAGER_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String TEXT_SERVICES_MANAGER_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get TEXT_SERVICES_MANAGER_SERVICE => + _id_TEXT_SERVICES_MANAGER_SERVICE.get(_class, const jni.JStringType()); + + static final _id_TV_INPUT_SERVICE = _class.staticFieldId( + r'TV_INPUT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String TV_INPUT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get TV_INPUT_SERVICE => + _id_TV_INPUT_SERVICE.get(_class, const jni.JStringType()); + + static final _id_TV_INTERACTIVE_APP_SERVICE = _class.staticFieldId( + r'TV_INTERACTIVE_APP_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String TV_INTERACTIVE_APP_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get TV_INTERACTIVE_APP_SERVICE => + _id_TV_INTERACTIVE_APP_SERVICE.get(_class, const jni.JStringType()); + + static final _id_UI_MODE_SERVICE = _class.staticFieldId( + r'UI_MODE_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String UI_MODE_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get UI_MODE_SERVICE => + _id_UI_MODE_SERVICE.get(_class, const jni.JStringType()); + + static final _id_USAGE_STATS_SERVICE = _class.staticFieldId( + r'USAGE_STATS_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String USAGE_STATS_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get USAGE_STATS_SERVICE => + _id_USAGE_STATS_SERVICE.get(_class, const jni.JStringType()); + + static final _id_USB_SERVICE = _class.staticFieldId( + r'USB_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String USB_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get USB_SERVICE => + _id_USB_SERVICE.get(_class, const jni.JStringType()); + + static final _id_USER_SERVICE = _class.staticFieldId( + r'USER_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String USER_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get USER_SERVICE => + _id_USER_SERVICE.get(_class, const jni.JStringType()); + + static final _id_VIBRATOR_MANAGER_SERVICE = _class.staticFieldId( + r'VIBRATOR_MANAGER_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String VIBRATOR_MANAGER_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get VIBRATOR_MANAGER_SERVICE => + _id_VIBRATOR_MANAGER_SERVICE.get(_class, const jni.JStringType()); + + static final _id_VIBRATOR_SERVICE = _class.staticFieldId( + r'VIBRATOR_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String VIBRATOR_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get VIBRATOR_SERVICE => + _id_VIBRATOR_SERVICE.get(_class, const jni.JStringType()); + + static final _id_VIRTUAL_DEVICE_SERVICE = _class.staticFieldId( + r'VIRTUAL_DEVICE_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String VIRTUAL_DEVICE_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get VIRTUAL_DEVICE_SERVICE => + _id_VIRTUAL_DEVICE_SERVICE.get(_class, const jni.JStringType()); + + static final _id_VPN_MANAGEMENT_SERVICE = _class.staticFieldId( + r'VPN_MANAGEMENT_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String VPN_MANAGEMENT_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get VPN_MANAGEMENT_SERVICE => + _id_VPN_MANAGEMENT_SERVICE.get(_class, const jni.JStringType()); + + static final _id_WALLPAPER_SERVICE = _class.staticFieldId( + r'WALLPAPER_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String WALLPAPER_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get WALLPAPER_SERVICE => + _id_WALLPAPER_SERVICE.get(_class, const jni.JStringType()); + + static final _id_WIFI_AWARE_SERVICE = _class.staticFieldId( + r'WIFI_AWARE_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String WIFI_AWARE_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get WIFI_AWARE_SERVICE => + _id_WIFI_AWARE_SERVICE.get(_class, const jni.JStringType()); + + static final _id_WIFI_P2P_SERVICE = _class.staticFieldId( + r'WIFI_P2P_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String WIFI_P2P_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get WIFI_P2P_SERVICE => + _id_WIFI_P2P_SERVICE.get(_class, const jni.JStringType()); + + static final _id_WIFI_RTT_RANGING_SERVICE = _class.staticFieldId( + r'WIFI_RTT_RANGING_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String WIFI_RTT_RANGING_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get WIFI_RTT_RANGING_SERVICE => + _id_WIFI_RTT_RANGING_SERVICE.get(_class, const jni.JStringType()); + + static final _id_WIFI_SERVICE = _class.staticFieldId( + r'WIFI_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String WIFI_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get WIFI_SERVICE => + _id_WIFI_SERVICE.get(_class, const jni.JStringType()); + + static final _id_WINDOW_SERVICE = _class.staticFieldId( + r'WINDOW_SERVICE', + r'Ljava/lang/String;', + ); + + /// from: static public final java.lang.String WINDOW_SERVICE + /// The returned object must be released after use, by calling the [release] method. + static jni.JString get WINDOW_SERVICE => + _id_WINDOW_SERVICE.get(_class, const jni.JStringType()); + + static final _id_new0 = _class.constructorId( + r'()V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void () + /// The returned object must be released after use, by calling the [release] method. + factory Context() { + return Context.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); + } + + static final _id_getAssets = _class.instanceMethodId( + r'getAssets', + r'()Landroid/content/res/AssetManager;', + ); + + static final _getAssets = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.content.res.AssetManager getAssets() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getAssets() { + return _getAssets(reference.pointer, _id_getAssets as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getResources = _class.instanceMethodId( + r'getResources', + r'()Landroid/content/res/Resources;', + ); + + static final _getResources = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.content.res.Resources getResources() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getResources() { + return _getResources( + reference.pointer, _id_getResources as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getPackageManager = _class.instanceMethodId( + r'getPackageManager', + r'()Landroid/content/pm/PackageManager;', + ); + + static final _getPackageManager = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.content.pm.PackageManager getPackageManager() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getPackageManager() { + return _getPackageManager( + reference.pointer, _id_getPackageManager as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getContentResolver = _class.instanceMethodId( + r'getContentResolver', + r'()Landroid/content/ContentResolver;', + ); + + static final _getContentResolver = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.content.ContentResolver getContentResolver() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getContentResolver() { + return _getContentResolver( + reference.pointer, _id_getContentResolver as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getMainLooper = _class.instanceMethodId( + r'getMainLooper', + r'()Landroid/os/Looper;', + ); + + static final _getMainLooper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.os.Looper getMainLooper() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getMainLooper() { + return _getMainLooper( + reference.pointer, _id_getMainLooper as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getMainExecutor = _class.instanceMethodId( + r'getMainExecutor', + r'()Ljava/util/concurrent/Executor;', + ); + + static final _getMainExecutor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.util.concurrent.Executor getMainExecutor() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getMainExecutor() { + return _getMainExecutor( + reference.pointer, _id_getMainExecutor as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getApplicationContext = _class.instanceMethodId( + r'getApplicationContext', + r'()Landroid/content/Context;', + ); + + static final _getApplicationContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.content.Context getApplicationContext() + /// The returned object must be released after use, by calling the [release] method. + Context getApplicationContext() { + return _getApplicationContext( + reference.pointer, _id_getApplicationContext as jni.JMethodIDPtr) + .object(const $ContextType()); + } + + static final _id_registerComponentCallbacks = _class.instanceMethodId( + r'registerComponentCallbacks', + r'(Landroid/content/ComponentCallbacks;)V', + ); + + static final _registerComponentCallbacks = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void registerComponentCallbacks(android.content.ComponentCallbacks componentCallbacks) + void registerComponentCallbacks( + jni.JObject componentCallbacks, + ) { + _registerComponentCallbacks( + reference.pointer, + _id_registerComponentCallbacks as jni.JMethodIDPtr, + componentCallbacks.reference.pointer) + .check(); + } + + static final _id_unregisterComponentCallbacks = _class.instanceMethodId( + r'unregisterComponentCallbacks', + r'(Landroid/content/ComponentCallbacks;)V', + ); + + static final _unregisterComponentCallbacks = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void unregisterComponentCallbacks(android.content.ComponentCallbacks componentCallbacks) + void unregisterComponentCallbacks( + jni.JObject componentCallbacks, + ) { + _unregisterComponentCallbacks( + reference.pointer, + _id_unregisterComponentCallbacks as jni.JMethodIDPtr, + componentCallbacks.reference.pointer) + .check(); + } + + static final _id_getText = _class.instanceMethodId( + r'getText', + r'(I)Ljava/lang/CharSequence;', + ); + + static final _getText = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final java.lang.CharSequence getText(int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getText( + int i, + ) { + return _getText(reference.pointer, _id_getText as jni.JMethodIDPtr, i) + .object(const jni.JObjectType()); + } + + static final _id_getString = _class.instanceMethodId( + r'getString', + r'(I)Ljava/lang/String;', + ); + + static final _getString = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final java.lang.String getString(int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JString getString( + int i, + ) { + return _getString(reference.pointer, _id_getString as jni.JMethodIDPtr, i) + .object(const jni.JStringType()); + } + + static final _id_getString1 = _class.instanceMethodId( + r'getString', + r'(I[Ljava/lang/Object;)Ljava/lang/String;', + ); + + static final _getString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public final java.lang.String getString(int i, java.lang.Object[] objects) + /// The returned object must be released after use, by calling the [release] method. + jni.JString getString1( + int i, + jni.JArray objects, + ) { + return _getString1(reference.pointer, _id_getString1 as jni.JMethodIDPtr, i, + objects.reference.pointer) + .object(const jni.JStringType()); + } + + static final _id_getColor = _class.instanceMethodId( + r'getColor', + r'(I)I', + ); + + static final _getColor = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final int getColor(int i) + int getColor( + int i, + ) { + return _getColor(reference.pointer, _id_getColor as jni.JMethodIDPtr, i) + .integer; + } + + static final _id_getDrawable = _class.instanceMethodId( + r'getDrawable', + r'(I)Landroid/graphics/drawable/Drawable;', + ); + + static final _getDrawable = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final android.graphics.drawable.Drawable getDrawable(int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getDrawable( + int i, + ) { + return _getDrawable( + reference.pointer, _id_getDrawable as jni.JMethodIDPtr, i) + .object(const jni.JObjectType()); + } + + static final _id_getColorStateList = _class.instanceMethodId( + r'getColorStateList', + r'(I)Landroid/content/res/ColorStateList;', + ); + + static final _getColorStateList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public final android.content.res.ColorStateList getColorStateList(int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getColorStateList( + int i, + ) { + return _getColorStateList( + reference.pointer, _id_getColorStateList as jni.JMethodIDPtr, i) + .object(const jni.JObjectType()); + } + + static final _id_setTheme = _class.instanceMethodId( + r'setTheme', + r'(I)V', + ); + + static final _setTheme = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public abstract void setTheme(int i) + void setTheme( + int i, + ) { + _setTheme(reference.pointer, _id_setTheme as jni.JMethodIDPtr, i).check(); + } + + static final _id_getTheme = _class.instanceMethodId( + r'getTheme', + r'()Landroid/content/res/Resources$Theme;', + ); + + static final _getTheme = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.content.res.Resources$Theme getTheme() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getTheme() { + return _getTheme(reference.pointer, _id_getTheme as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_obtainStyledAttributes = _class.instanceMethodId( + r'obtainStyledAttributes', + r'([I)Landroid/content/res/TypedArray;', + ); + + static final _obtainStyledAttributes = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public final android.content.res.TypedArray obtainStyledAttributes(int[] is) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject obtainStyledAttributes( + jni.JArray is0, + ) { + return _obtainStyledAttributes( + reference.pointer, + _id_obtainStyledAttributes as jni.JMethodIDPtr, + is0.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_obtainStyledAttributes1 = _class.instanceMethodId( + r'obtainStyledAttributes', + r'(I[I)Landroid/content/res/TypedArray;', + ); + + static final _obtainStyledAttributes1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public final android.content.res.TypedArray obtainStyledAttributes(int i, int[] is) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject obtainStyledAttributes1( + int i, + jni.JArray is0, + ) { + return _obtainStyledAttributes1( + reference.pointer, + _id_obtainStyledAttributes1 as jni.JMethodIDPtr, + i, + is0.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_obtainStyledAttributes2 = _class.instanceMethodId( + r'obtainStyledAttributes', + r'(Landroid/util/AttributeSet;[I)Landroid/content/res/TypedArray;', + ); + + static final _obtainStyledAttributes2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public final android.content.res.TypedArray obtainStyledAttributes(android.util.AttributeSet attributeSet, int[] is) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject obtainStyledAttributes2( + jni.JObject attributeSet, + jni.JArray is0, + ) { + return _obtainStyledAttributes2( + reference.pointer, + _id_obtainStyledAttributes2 as jni.JMethodIDPtr, + attributeSet.reference.pointer, + is0.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_obtainStyledAttributes3 = _class.instanceMethodId( + r'obtainStyledAttributes', + r'(Landroid/util/AttributeSet;[III)Landroid/content/res/TypedArray;', + ); + + static final _obtainStyledAttributes3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + $Int32 + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int, int)>(); + + /// from: public final android.content.res.TypedArray obtainStyledAttributes(android.util.AttributeSet attributeSet, int[] is, int i, int i1) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject obtainStyledAttributes3( + jni.JObject attributeSet, + jni.JArray is0, + int i, + int i1, + ) { + return _obtainStyledAttributes3( + reference.pointer, + _id_obtainStyledAttributes3 as jni.JMethodIDPtr, + attributeSet.reference.pointer, + is0.reference.pointer, + i, + i1) + .object(const jni.JObjectType()); + } + + static final _id_getClassLoader = _class.instanceMethodId( + r'getClassLoader', + r'()Ljava/lang/ClassLoader;', + ); + + static final _getClassLoader = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.ClassLoader getClassLoader() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getClassLoader() { + return _getClassLoader( + reference.pointer, _id_getClassLoader as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getPackageName = _class.instanceMethodId( + r'getPackageName', + r'()Ljava/lang/String;', + ); + + static final _getPackageName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getPackageName() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getPackageName() { + return _getPackageName( + reference.pointer, _id_getPackageName as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getOpPackageName = _class.instanceMethodId( + r'getOpPackageName', + r'()Ljava/lang/String;', + ); + + static final _getOpPackageName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getOpPackageName() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getOpPackageName() { + return _getOpPackageName( + reference.pointer, _id_getOpPackageName as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getAttributionTag = _class.instanceMethodId( + r'getAttributionTag', + r'()Ljava/lang/String;', + ); + + static final _getAttributionTag = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String getAttributionTag() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getAttributionTag() { + return _getAttributionTag( + reference.pointer, _id_getAttributionTag as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getAttributionSource = _class.instanceMethodId( + r'getAttributionSource', + r'()Landroid/content/AttributionSource;', + ); + + static final _getAttributionSource = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.content.AttributionSource getAttributionSource() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getAttributionSource() { + return _getAttributionSource( + reference.pointer, _id_getAttributionSource as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getParams = _class.instanceMethodId( + r'getParams', + r'()Landroid/content/ContextParams;', + ); + + static final _getParams = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.content.ContextParams getParams() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getParams() { + return _getParams(reference.pointer, _id_getParams as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getApplicationInfo = _class.instanceMethodId( + r'getApplicationInfo', + r'()Landroid/content/pm/ApplicationInfo;', + ); + + static final _getApplicationInfo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.content.pm.ApplicationInfo getApplicationInfo() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getApplicationInfo() { + return _getApplicationInfo( + reference.pointer, _id_getApplicationInfo as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getPackageResourcePath = _class.instanceMethodId( + r'getPackageResourcePath', + r'()Ljava/lang/String;', + ); + + static final _getPackageResourcePath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getPackageResourcePath() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getPackageResourcePath() { + return _getPackageResourcePath( + reference.pointer, _id_getPackageResourcePath as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getPackageCodePath = _class.instanceMethodId( + r'getPackageCodePath', + r'()Ljava/lang/String;', + ); + + static final _getPackageCodePath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getPackageCodePath() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getPackageCodePath() { + return _getPackageCodePath( + reference.pointer, _id_getPackageCodePath as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getSharedPreferences = _class.instanceMethodId( + r'getSharedPreferences', + r'(Ljava/lang/String;I)Landroid/content/SharedPreferences;', + ); + + static final _getSharedPreferences = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public abstract android.content.SharedPreferences getSharedPreferences(java.lang.String string, int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSharedPreferences( + jni.JString string, + int i, + ) { + return _getSharedPreferences( + reference.pointer, + _id_getSharedPreferences as jni.JMethodIDPtr, + string.reference.pointer, + i) + .object(const jni.JObjectType()); + } + + static final _id_moveSharedPreferencesFrom = _class.instanceMethodId( + r'moveSharedPreferencesFrom', + r'(Landroid/content/Context;Ljava/lang/String;)Z', + ); + + static final _moveSharedPreferencesFrom = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract boolean moveSharedPreferencesFrom(android.content.Context context, java.lang.String string) + bool moveSharedPreferencesFrom( + Context context, + jni.JString string, + ) { + return _moveSharedPreferencesFrom( + reference.pointer, + _id_moveSharedPreferencesFrom as jni.JMethodIDPtr, + context.reference.pointer, + string.reference.pointer) + .boolean; + } + + static final _id_deleteSharedPreferences = _class.instanceMethodId( + r'deleteSharedPreferences', + r'(Ljava/lang/String;)Z', + ); + + static final _deleteSharedPreferences = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract boolean deleteSharedPreferences(java.lang.String string) + bool deleteSharedPreferences( + jni.JString string, + ) { + return _deleteSharedPreferences( + reference.pointer, + _id_deleteSharedPreferences as jni.JMethodIDPtr, + string.reference.pointer) + .boolean; + } + + static final _id_openFileInput = _class.instanceMethodId( + r'openFileInput', + r'(Ljava/lang/String;)Ljava/io/FileInputStream;', + ); + + static final _openFileInput = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract java.io.FileInputStream openFileInput(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject openFileInput( + jni.JString string, + ) { + return _openFileInput(reference.pointer, + _id_openFileInput as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_openFileOutput = _class.instanceMethodId( + r'openFileOutput', + r'(Ljava/lang/String;I)Ljava/io/FileOutputStream;', + ); + + static final _openFileOutput = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public abstract java.io.FileOutputStream openFileOutput(java.lang.String string, int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject openFileOutput( + jni.JString string, + int i, + ) { + return _openFileOutput(reference.pointer, + _id_openFileOutput as jni.JMethodIDPtr, string.reference.pointer, i) + .object(const jni.JObjectType()); + } + + static final _id_deleteFile = _class.instanceMethodId( + r'deleteFile', + r'(Ljava/lang/String;)Z', + ); + + static final _deleteFile = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract boolean deleteFile(java.lang.String string) + bool deleteFile( + jni.JString string, + ) { + return _deleteFile(reference.pointer, _id_deleteFile as jni.JMethodIDPtr, + string.reference.pointer) + .boolean; + } + + static final _id_getFileStreamPath = _class.instanceMethodId( + r'getFileStreamPath', + r'(Ljava/lang/String;)Ljava/io/File;', + ); + + static final _getFileStreamPath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract java.io.File getFileStreamPath(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getFileStreamPath( + jni.JString string, + ) { + return _getFileStreamPath(reference.pointer, + _id_getFileStreamPath as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getDataDir = _class.instanceMethodId( + r'getDataDir', + r'()Ljava/io/File;', + ); + + static final _getDataDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File getDataDir() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getDataDir() { + return _getDataDir(reference.pointer, _id_getDataDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getFilesDir = _class.instanceMethodId( + r'getFilesDir', + r'()Ljava/io/File;', + ); + + static final _getFilesDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File getFilesDir() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getFilesDir() { + return _getFilesDir(reference.pointer, _id_getFilesDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getNoBackupFilesDir = _class.instanceMethodId( + r'getNoBackupFilesDir', + r'()Ljava/io/File;', + ); + + static final _getNoBackupFilesDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File getNoBackupFilesDir() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getNoBackupFilesDir() { + return _getNoBackupFilesDir( + reference.pointer, _id_getNoBackupFilesDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getExternalFilesDir = _class.instanceMethodId( + r'getExternalFilesDir', + r'(Ljava/lang/String;)Ljava/io/File;', + ); + + static final _getExternalFilesDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract java.io.File getExternalFilesDir(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getExternalFilesDir( + jni.JString string, + ) { + return _getExternalFilesDir( + reference.pointer, + _id_getExternalFilesDir as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getExternalFilesDirs = _class.instanceMethodId( + r'getExternalFilesDirs', + r'(Ljava/lang/String;)[Ljava/io/File;', + ); + + static final _getExternalFilesDirs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract java.io.File[] getExternalFilesDirs(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getExternalFilesDirs( + jni.JString string, + ) { + return _getExternalFilesDirs( + reference.pointer, + _id_getExternalFilesDirs as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JArrayType(jni.JObjectType())); + } + + static final _id_getObbDir = _class.instanceMethodId( + r'getObbDir', + r'()Ljava/io/File;', + ); + + static final _getObbDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File getObbDir() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getObbDir() { + return _getObbDir(reference.pointer, _id_getObbDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getObbDirs = _class.instanceMethodId( + r'getObbDirs', + r'()[Ljava/io/File;', + ); + + static final _getObbDirs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File[] getObbDirs() + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getObbDirs() { + return _getObbDirs(reference.pointer, _id_getObbDirs as jni.JMethodIDPtr) + .object(const jni.JArrayType(jni.JObjectType())); + } + + static final _id_getCacheDir = _class.instanceMethodId( + r'getCacheDir', + r'()Ljava/io/File;', + ); + + static final _getCacheDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File getCacheDir() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getCacheDir() { + return _getCacheDir(reference.pointer, _id_getCacheDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getCodeCacheDir = _class.instanceMethodId( + r'getCodeCacheDir', + r'()Ljava/io/File;', + ); + + static final _getCodeCacheDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File getCodeCacheDir() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getCodeCacheDir() { + return _getCodeCacheDir( + reference.pointer, _id_getCodeCacheDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getExternalCacheDir = _class.instanceMethodId( + r'getExternalCacheDir', + r'()Ljava/io/File;', + ); + + static final _getExternalCacheDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File getExternalCacheDir() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getExternalCacheDir() { + return _getExternalCacheDir( + reference.pointer, _id_getExternalCacheDir as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getExternalCacheDirs = _class.instanceMethodId( + r'getExternalCacheDirs', + r'()[Ljava/io/File;', + ); + + static final _getExternalCacheDirs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File[] getExternalCacheDirs() + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getExternalCacheDirs() { + return _getExternalCacheDirs( + reference.pointer, _id_getExternalCacheDirs as jni.JMethodIDPtr) + .object(const jni.JArrayType(jni.JObjectType())); + } + + static final _id_getExternalMediaDirs = _class.instanceMethodId( + r'getExternalMediaDirs', + r'()[Ljava/io/File;', + ); + + static final _getExternalMediaDirs = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.io.File[] getExternalMediaDirs() + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getExternalMediaDirs() { + return _getExternalMediaDirs( + reference.pointer, _id_getExternalMediaDirs as jni.JMethodIDPtr) + .object(const jni.JArrayType(jni.JObjectType())); + } + + static final _id_fileList = _class.instanceMethodId( + r'fileList', + r'()[Ljava/lang/String;', + ); + + static final _fileList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String[] fileList() + /// The returned object must be released after use, by calling the [release] method. + jni.JArray fileList() { + return _fileList(reference.pointer, _id_fileList as jni.JMethodIDPtr) + .object(const jni.JArrayType(jni.JStringType())); + } + + static final _id_getDir = _class.instanceMethodId( + r'getDir', + r'(Ljava/lang/String;I)Ljava/io/File;', + ); + + static final _getDir = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public abstract java.io.File getDir(java.lang.String string, int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getDir( + jni.JString string, + int i, + ) { + return _getDir(reference.pointer, _id_getDir as jni.JMethodIDPtr, + string.reference.pointer, i) + .object(const jni.JObjectType()); + } + + static final _id_openOrCreateDatabase = _class.instanceMethodId( + r'openOrCreateDatabase', + r'(Ljava/lang/String;ILandroid/database/sqlite/SQLiteDatabase$CursorFactory;)Landroid/database/sqlite/SQLiteDatabase;', + ); + + static final _openOrCreateDatabase = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); + + /// from: public abstract android.database.sqlite.SQLiteDatabase openOrCreateDatabase(java.lang.String string, int i, android.database.sqlite.SQLiteDatabase$CursorFactory cursorFactory) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject openOrCreateDatabase( + jni.JString string, + int i, + jni.JObject cursorFactory, + ) { + return _openOrCreateDatabase( + reference.pointer, + _id_openOrCreateDatabase as jni.JMethodIDPtr, + string.reference.pointer, + i, + cursorFactory.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_openOrCreateDatabase1 = _class.instanceMethodId( + r'openOrCreateDatabase', + r'(Ljava/lang/String;ILandroid/database/sqlite/SQLiteDatabase$CursorFactory;Landroid/database/DatabaseErrorHandler;)Landroid/database/sqlite/SQLiteDatabase;', + ); + + static final _openOrCreateDatabase1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public abstract android.database.sqlite.SQLiteDatabase openOrCreateDatabase(java.lang.String string, int i, android.database.sqlite.SQLiteDatabase$CursorFactory cursorFactory, android.database.DatabaseErrorHandler databaseErrorHandler) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject openOrCreateDatabase1( + jni.JString string, + int i, + jni.JObject cursorFactory, + jni.JObject databaseErrorHandler, + ) { + return _openOrCreateDatabase1( + reference.pointer, + _id_openOrCreateDatabase1 as jni.JMethodIDPtr, + string.reference.pointer, + i, + cursorFactory.reference.pointer, + databaseErrorHandler.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_moveDatabaseFrom = _class.instanceMethodId( + r'moveDatabaseFrom', + r'(Landroid/content/Context;Ljava/lang/String;)Z', + ); + + static final _moveDatabaseFrom = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract boolean moveDatabaseFrom(android.content.Context context, java.lang.String string) + bool moveDatabaseFrom( + Context context, + jni.JString string, + ) { + return _moveDatabaseFrom( + reference.pointer, + _id_moveDatabaseFrom as jni.JMethodIDPtr, + context.reference.pointer, + string.reference.pointer) + .boolean; + } + + static final _id_deleteDatabase = _class.instanceMethodId( + r'deleteDatabase', + r'(Ljava/lang/String;)Z', + ); + + static final _deleteDatabase = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract boolean deleteDatabase(java.lang.String string) + bool deleteDatabase( + jni.JString string, + ) { + return _deleteDatabase(reference.pointer, + _id_deleteDatabase as jni.JMethodIDPtr, string.reference.pointer) + .boolean; + } + + static final _id_getDatabasePath = _class.instanceMethodId( + r'getDatabasePath', + r'(Ljava/lang/String;)Ljava/io/File;', + ); + + static final _getDatabasePath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract java.io.File getDatabasePath(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getDatabasePath( + jni.JString string, + ) { + return _getDatabasePath(reference.pointer, + _id_getDatabasePath as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_databaseList = _class.instanceMethodId( + r'databaseList', + r'()[Ljava/lang/String;', + ); + + static final _databaseList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String[] databaseList() + /// The returned object must be released after use, by calling the [release] method. + jni.JArray databaseList() { + return _databaseList( + reference.pointer, _id_databaseList as jni.JMethodIDPtr) + .object(const jni.JArrayType(jni.JStringType())); + } + + static final _id_getWallpaper = _class.instanceMethodId( + r'getWallpaper', + r'()Landroid/graphics/drawable/Drawable;', + ); + + static final _getWallpaper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.graphics.drawable.Drawable getWallpaper() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getWallpaper() { + return _getWallpaper( + reference.pointer, _id_getWallpaper as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_peekWallpaper = _class.instanceMethodId( + r'peekWallpaper', + r'()Landroid/graphics/drawable/Drawable;', + ); + + static final _peekWallpaper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.graphics.drawable.Drawable peekWallpaper() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject peekWallpaper() { + return _peekWallpaper( + reference.pointer, _id_peekWallpaper as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getWallpaperDesiredMinimumWidth = _class.instanceMethodId( + r'getWallpaperDesiredMinimumWidth', + r'()I', + ); + + static final _getWallpaperDesiredMinimumWidth = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract int getWallpaperDesiredMinimumWidth() + int getWallpaperDesiredMinimumWidth() { + return _getWallpaperDesiredMinimumWidth(reference.pointer, + _id_getWallpaperDesiredMinimumWidth as jni.JMethodIDPtr) + .integer; + } + + static final _id_getWallpaperDesiredMinimumHeight = _class.instanceMethodId( + r'getWallpaperDesiredMinimumHeight', + r'()I', + ); + + static final _getWallpaperDesiredMinimumHeight = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract int getWallpaperDesiredMinimumHeight() + int getWallpaperDesiredMinimumHeight() { + return _getWallpaperDesiredMinimumHeight(reference.pointer, + _id_getWallpaperDesiredMinimumHeight as jni.JMethodIDPtr) + .integer; + } + + static final _id_setWallpaper = _class.instanceMethodId( + r'setWallpaper', + r'(Landroid/graphics/Bitmap;)V', + ); + + static final _setWallpaper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void setWallpaper(android.graphics.Bitmap bitmap) + void setWallpaper( + jni.JObject bitmap, + ) { + _setWallpaper(reference.pointer, _id_setWallpaper as jni.JMethodIDPtr, + bitmap.reference.pointer) + .check(); + } + + static final _id_setWallpaper1 = _class.instanceMethodId( + r'setWallpaper', + r'(Ljava/io/InputStream;)V', + ); + + static final _setWallpaper1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void setWallpaper(java.io.InputStream inputStream) + void setWallpaper1( + jni.JObject inputStream, + ) { + _setWallpaper1(reference.pointer, _id_setWallpaper1 as jni.JMethodIDPtr, + inputStream.reference.pointer) + .check(); + } + + static final _id_clearWallpaper = _class.instanceMethodId( + r'clearWallpaper', + r'()V', + ); + + static final _clearWallpaper = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract void clearWallpaper() + void clearWallpaper() { + _clearWallpaper(reference.pointer, _id_clearWallpaper as jni.JMethodIDPtr) + .check(); + } + + static final _id_startActivity = _class.instanceMethodId( + r'startActivity', + r'(Landroid/content/Intent;)V', + ); + + static final _startActivity = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void startActivity(android.content.Intent intent) + void startActivity( + jni.JObject intent, + ) { + _startActivity(reference.pointer, _id_startActivity as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); + } + + static final _id_startActivity1 = _class.instanceMethodId( + r'startActivity', + r'(Landroid/content/Intent;Landroid/os/Bundle;)V', + ); + + static final _startActivity1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract void startActivity(android.content.Intent intent, android.os.Bundle bundle) + void startActivity1( + jni.JObject intent, + Bundle bundle, + ) { + _startActivity1(reference.pointer, _id_startActivity1 as jni.JMethodIDPtr, + intent.reference.pointer, bundle.reference.pointer) + .check(); + } + + static final _id_startActivities = _class.instanceMethodId( + r'startActivities', + r'([Landroid/content/Intent;)V', + ); + + static final _startActivities = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void startActivities(android.content.Intent[] intents) + void startActivities( + jni.JArray intents, + ) { + _startActivities(reference.pointer, _id_startActivities as jni.JMethodIDPtr, + intents.reference.pointer) + .check(); + } + + static final _id_startActivities1 = _class.instanceMethodId( + r'startActivities', + r'([Landroid/content/Intent;Landroid/os/Bundle;)V', + ); + + static final _startActivities1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract void startActivities(android.content.Intent[] intents, android.os.Bundle bundle) + void startActivities1( + jni.JArray intents, + Bundle bundle, + ) { + _startActivities1( + reference.pointer, + _id_startActivities1 as jni.JMethodIDPtr, + intents.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_startIntentSender = _class.instanceMethodId( + r'startIntentSender', + r'(Landroid/content/IntentSender;Landroid/content/Intent;III)V', + ); + + static final _startIntentSender = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + $Int32, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int, int, int)>(); + + /// from: public abstract void startIntentSender(android.content.IntentSender intentSender, android.content.Intent intent, int i, int i1, int i2) + void startIntentSender( + jni.JObject intentSender, + jni.JObject intent, + int i, + int i1, + int i2, + ) { + _startIntentSender( + reference.pointer, + _id_startIntentSender as jni.JMethodIDPtr, + intentSender.reference.pointer, + intent.reference.pointer, + i, + i1, + i2) + .check(); + } + + static final _id_startIntentSender1 = _class.instanceMethodId( + r'startIntentSender', + r'(Landroid/content/IntentSender;Landroid/content/Intent;IIILandroid/os/Bundle;)V', + ); + + static final _startIntentSender1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + $Int32, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer)>(); + + /// from: public abstract void startIntentSender(android.content.IntentSender intentSender, android.content.Intent intent, int i, int i1, int i2, android.os.Bundle bundle) + void startIntentSender1( + jni.JObject intentSender, + jni.JObject intent, + int i, + int i1, + int i2, + Bundle bundle, + ) { + _startIntentSender1( + reference.pointer, + _id_startIntentSender1 as jni.JMethodIDPtr, + intentSender.reference.pointer, + intent.reference.pointer, + i, + i1, + i2, + bundle.reference.pointer) + .check(); + } + + static final _id_sendBroadcast = _class.instanceMethodId( + r'sendBroadcast', + r'(Landroid/content/Intent;)V', + ); + + static final _sendBroadcast = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void sendBroadcast(android.content.Intent intent) + void sendBroadcast( + jni.JObject intent, + ) { + _sendBroadcast(reference.pointer, _id_sendBroadcast as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); + } + + static final _id_sendBroadcast1 = _class.instanceMethodId( + r'sendBroadcast', + r'(Landroid/content/Intent;Ljava/lang/String;)V', + ); + + static final _sendBroadcast1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract void sendBroadcast(android.content.Intent intent, java.lang.String string) + void sendBroadcast1( + jni.JObject intent, + jni.JString string, + ) { + _sendBroadcast1(reference.pointer, _id_sendBroadcast1 as jni.JMethodIDPtr, + intent.reference.pointer, string.reference.pointer) + .check(); + } + + static final _id_sendBroadcastWithMultiplePermissions = + _class.instanceMethodId( + r'sendBroadcastWithMultiplePermissions', + r'(Landroid/content/Intent;[Ljava/lang/String;)V', + ); + + static final _sendBroadcastWithMultiplePermissions = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public void sendBroadcastWithMultiplePermissions(android.content.Intent intent, java.lang.String[] strings) + void sendBroadcastWithMultiplePermissions( + jni.JObject intent, + jni.JArray strings, + ) { + _sendBroadcastWithMultiplePermissions( + reference.pointer, + _id_sendBroadcastWithMultiplePermissions as jni.JMethodIDPtr, + intent.reference.pointer, + strings.reference.pointer) + .check(); + } + + static final _id_sendBroadcast2 = _class.instanceMethodId( + r'sendBroadcast', + r'(Landroid/content/Intent;Ljava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _sendBroadcast2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public void sendBroadcast(android.content.Intent intent, java.lang.String string, android.os.Bundle bundle) + void sendBroadcast2( + jni.JObject intent, + jni.JString string, + Bundle bundle, + ) { + _sendBroadcast2( + reference.pointer, + _id_sendBroadcast2 as jni.JMethodIDPtr, + intent.reference.pointer, + string.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_sendOrderedBroadcast = _class.instanceMethodId( + r'sendOrderedBroadcast', + r'(Landroid/content/Intent;Ljava/lang/String;)V', + ); + + static final _sendOrderedBroadcast = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract void sendOrderedBroadcast(android.content.Intent intent, java.lang.String string) + void sendOrderedBroadcast( + jni.JObject intent, + jni.JString string, + ) { + _sendOrderedBroadcast( + reference.pointer, + _id_sendOrderedBroadcast as jni.JMethodIDPtr, + intent.reference.pointer, + string.reference.pointer) + .check(); + } + + static final _id_sendOrderedBroadcast1 = _class.instanceMethodId( + r'sendOrderedBroadcast', + r'(Landroid/content/Intent;Ljava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _sendOrderedBroadcast1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public void sendOrderedBroadcast(android.content.Intent intent, java.lang.String string, android.os.Bundle bundle) + void sendOrderedBroadcast1( + jni.JObject intent, + jni.JString string, + Bundle bundle, + ) { + _sendOrderedBroadcast1( + reference.pointer, + _id_sendOrderedBroadcast1 as jni.JMethodIDPtr, + intent.reference.pointer, + string.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_sendOrderedBroadcast2 = _class.instanceMethodId( + r'sendOrderedBroadcast', + r'(Landroid/content/Intent;Ljava/lang/String;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _sendOrderedBroadcast2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public abstract void sendOrderedBroadcast(android.content.Intent intent, java.lang.String string, android.content.BroadcastReceiver broadcastReceiver, android.os.Handler handler, int i, java.lang.String string1, android.os.Bundle bundle) + void sendOrderedBroadcast2( + jni.JObject intent, + jni.JString string, + jni.JObject broadcastReceiver, + jni.JObject handler, + int i, + jni.JString string1, + Bundle bundle, + ) { + _sendOrderedBroadcast2( + reference.pointer, + _id_sendOrderedBroadcast2 as jni.JMethodIDPtr, + intent.reference.pointer, + string.reference.pointer, + broadcastReceiver.reference.pointer, + handler.reference.pointer, + i, + string1.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_sendOrderedBroadcast3 = _class.instanceMethodId( + r'sendOrderedBroadcast', + r'(Landroid/content/Intent;Ljava/lang/String;Landroid/os/Bundle;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _sendOrderedBroadcast3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public void sendOrderedBroadcast(android.content.Intent intent, java.lang.String string, android.os.Bundle bundle, android.content.BroadcastReceiver broadcastReceiver, android.os.Handler handler, int i, java.lang.String string1, android.os.Bundle bundle1) + void sendOrderedBroadcast3( + jni.JObject intent, + jni.JString string, + Bundle bundle, + jni.JObject broadcastReceiver, + jni.JObject handler, + int i, + jni.JString string1, + Bundle bundle1, + ) { + _sendOrderedBroadcast3( + reference.pointer, + _id_sendOrderedBroadcast3 as jni.JMethodIDPtr, + intent.reference.pointer, + string.reference.pointer, + bundle.reference.pointer, + broadcastReceiver.reference.pointer, + handler.reference.pointer, + i, + string1.reference.pointer, + bundle1.reference.pointer) + .check(); + } + + static final _id_sendBroadcastAsUser = _class.instanceMethodId( + r'sendBroadcastAsUser', + r'(Landroid/content/Intent;Landroid/os/UserHandle;)V', + ); + + static final _sendBroadcastAsUser = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract void sendBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle) + void sendBroadcastAsUser( + jni.JObject intent, + jni.JObject userHandle, + ) { + _sendBroadcastAsUser( + reference.pointer, + _id_sendBroadcastAsUser as jni.JMethodIDPtr, + intent.reference.pointer, + userHandle.reference.pointer) + .check(); + } + + static final _id_sendBroadcastAsUser1 = _class.instanceMethodId( + r'sendBroadcastAsUser', + r'(Landroid/content/Intent;Landroid/os/UserHandle;Ljava/lang/String;)V', + ); + + static final _sendBroadcastAsUser1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public abstract void sendBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle, java.lang.String string) + void sendBroadcastAsUser1( + jni.JObject intent, + jni.JObject userHandle, + jni.JString string, + ) { + _sendBroadcastAsUser1( + reference.pointer, + _id_sendBroadcastAsUser1 as jni.JMethodIDPtr, + intent.reference.pointer, + userHandle.reference.pointer, + string.reference.pointer) + .check(); + } + + static final _id_sendOrderedBroadcastAsUser = _class.instanceMethodId( + r'sendOrderedBroadcastAsUser', + r'(Landroid/content/Intent;Landroid/os/UserHandle;Ljava/lang/String;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _sendOrderedBroadcastAsUser = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public abstract void sendOrderedBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle, java.lang.String string, android.content.BroadcastReceiver broadcastReceiver, android.os.Handler handler, int i, java.lang.String string1, android.os.Bundle bundle) + void sendOrderedBroadcastAsUser( + jni.JObject intent, + jni.JObject userHandle, + jni.JString string, + jni.JObject broadcastReceiver, + jni.JObject handler, + int i, + jni.JString string1, + Bundle bundle, + ) { + _sendOrderedBroadcastAsUser( + reference.pointer, + _id_sendOrderedBroadcastAsUser as jni.JMethodIDPtr, + intent.reference.pointer, + userHandle.reference.pointer, + string.reference.pointer, + broadcastReceiver.reference.pointer, + handler.reference.pointer, + i, + string1.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_sendOrderedBroadcast4 = _class.instanceMethodId( + r'sendOrderedBroadcast', + r'(Landroid/content/Intent;Ljava/lang/String;Ljava/lang/String;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _sendOrderedBroadcast4 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public void sendOrderedBroadcast(android.content.Intent intent, java.lang.String string, java.lang.String string1, android.content.BroadcastReceiver broadcastReceiver, android.os.Handler handler, int i, java.lang.String string2, android.os.Bundle bundle) + void sendOrderedBroadcast4( + jni.JObject intent, + jni.JString string, + jni.JString string1, + jni.JObject broadcastReceiver, + jni.JObject handler, + int i, + jni.JString string2, + Bundle bundle, + ) { + _sendOrderedBroadcast4( + reference.pointer, + _id_sendOrderedBroadcast4 as jni.JMethodIDPtr, + intent.reference.pointer, + string.reference.pointer, + string1.reference.pointer, + broadcastReceiver.reference.pointer, + handler.reference.pointer, + i, + string2.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_sendStickyBroadcast = _class.instanceMethodId( + r'sendStickyBroadcast', + r'(Landroid/content/Intent;)V', + ); + + static final _sendStickyBroadcast = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void sendStickyBroadcast(android.content.Intent intent) + void sendStickyBroadcast( + jni.JObject intent, + ) { + _sendStickyBroadcast( + reference.pointer, + _id_sendStickyBroadcast as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); + } + + static final _id_sendStickyBroadcast1 = _class.instanceMethodId( + r'sendStickyBroadcast', + r'(Landroid/content/Intent;Landroid/os/Bundle;)V', + ); + + static final _sendStickyBroadcast1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void sendStickyBroadcast(android.content.Intent intent, android.os.Bundle bundle) + void sendStickyBroadcast1( + jni.JObject intent, + Bundle bundle, + ) { + _sendStickyBroadcast1( + reference.pointer, + _id_sendStickyBroadcast1 as jni.JMethodIDPtr, + intent.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_sendStickyOrderedBroadcast = _class.instanceMethodId( + r'sendStickyOrderedBroadcast', + r'(Landroid/content/Intent;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _sendStickyOrderedBroadcast = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public abstract void sendStickyOrderedBroadcast(android.content.Intent intent, android.content.BroadcastReceiver broadcastReceiver, android.os.Handler handler, int i, java.lang.String string, android.os.Bundle bundle) + void sendStickyOrderedBroadcast( + jni.JObject intent, + jni.JObject broadcastReceiver, + jni.JObject handler, + int i, + jni.JString string, + Bundle bundle, + ) { + _sendStickyOrderedBroadcast( + reference.pointer, + _id_sendStickyOrderedBroadcast as jni.JMethodIDPtr, + intent.reference.pointer, + broadcastReceiver.reference.pointer, + handler.reference.pointer, + i, + string.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_removeStickyBroadcast = _class.instanceMethodId( + r'removeStickyBroadcast', + r'(Landroid/content/Intent;)V', + ); + + static final _removeStickyBroadcast = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void removeStickyBroadcast(android.content.Intent intent) + void removeStickyBroadcast( + jni.JObject intent, + ) { + _removeStickyBroadcast( + reference.pointer, + _id_removeStickyBroadcast as jni.JMethodIDPtr, + intent.reference.pointer) + .check(); + } + + static final _id_sendStickyBroadcastAsUser = _class.instanceMethodId( + r'sendStickyBroadcastAsUser', + r'(Landroid/content/Intent;Landroid/os/UserHandle;)V', + ); + + static final _sendStickyBroadcastAsUser = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract void sendStickyBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle) + void sendStickyBroadcastAsUser( + jni.JObject intent, + jni.JObject userHandle, + ) { + _sendStickyBroadcastAsUser( + reference.pointer, + _id_sendStickyBroadcastAsUser as jni.JMethodIDPtr, + intent.reference.pointer, + userHandle.reference.pointer) + .check(); + } + + static final _id_sendStickyOrderedBroadcastAsUser = _class.instanceMethodId( + r'sendStickyOrderedBroadcastAsUser', + r'(Landroid/content/Intent;Landroid/os/UserHandle;Landroid/content/BroadcastReceiver;Landroid/os/Handler;ILjava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _sendStickyOrderedBroadcastAsUser = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public abstract void sendStickyOrderedBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle, android.content.BroadcastReceiver broadcastReceiver, android.os.Handler handler, int i, java.lang.String string, android.os.Bundle bundle) + void sendStickyOrderedBroadcastAsUser( + jni.JObject intent, + jni.JObject userHandle, + jni.JObject broadcastReceiver, + jni.JObject handler, + int i, + jni.JString string, + Bundle bundle, + ) { + _sendStickyOrderedBroadcastAsUser( + reference.pointer, + _id_sendStickyOrderedBroadcastAsUser as jni.JMethodIDPtr, + intent.reference.pointer, + userHandle.reference.pointer, + broadcastReceiver.reference.pointer, + handler.reference.pointer, + i, + string.reference.pointer, + bundle.reference.pointer) + .check(); + } + + static final _id_removeStickyBroadcastAsUser = _class.instanceMethodId( + r'removeStickyBroadcastAsUser', + r'(Landroid/content/Intent;Landroid/os/UserHandle;)V', + ); + + static final _removeStickyBroadcastAsUser = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract void removeStickyBroadcastAsUser(android.content.Intent intent, android.os.UserHandle userHandle) + void removeStickyBroadcastAsUser( + jni.JObject intent, + jni.JObject userHandle, + ) { + _removeStickyBroadcastAsUser( + reference.pointer, + _id_removeStickyBroadcastAsUser as jni.JMethodIDPtr, + intent.reference.pointer, + userHandle.reference.pointer) + .check(); + } + + static final _id_registerReceiver = _class.instanceMethodId( + r'registerReceiver', + r'(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;)Landroid/content/Intent;', + ); + + static final _registerReceiver = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract android.content.Intent registerReceiver(android.content.BroadcastReceiver broadcastReceiver, android.content.IntentFilter intentFilter) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject registerReceiver( + jni.JObject broadcastReceiver, + jni.JObject intentFilter, + ) { + return _registerReceiver( + reference.pointer, + _id_registerReceiver as jni.JMethodIDPtr, + broadcastReceiver.reference.pointer, + intentFilter.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_registerReceiver1 = _class.instanceMethodId( + r'registerReceiver', + r'(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;I)Landroid/content/Intent;', + ); + + static final _registerReceiver1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32 + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); + + /// from: public abstract android.content.Intent registerReceiver(android.content.BroadcastReceiver broadcastReceiver, android.content.IntentFilter intentFilter, int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject registerReceiver1( + jni.JObject broadcastReceiver, + jni.JObject intentFilter, + int i, + ) { + return _registerReceiver1( + reference.pointer, + _id_registerReceiver1 as jni.JMethodIDPtr, + broadcastReceiver.reference.pointer, + intentFilter.reference.pointer, + i) + .object(const jni.JObjectType()); + } + + static final _id_registerReceiver2 = _class.instanceMethodId( + r'registerReceiver', + r'(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;Ljava/lang/String;Landroid/os/Handler;)Landroid/content/Intent;', + ); + + static final _registerReceiver2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public abstract android.content.Intent registerReceiver(android.content.BroadcastReceiver broadcastReceiver, android.content.IntentFilter intentFilter, java.lang.String string, android.os.Handler handler) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject registerReceiver2( + jni.JObject broadcastReceiver, + jni.JObject intentFilter, + jni.JString string, + jni.JObject handler, + ) { + return _registerReceiver2( + reference.pointer, + _id_registerReceiver2 as jni.JMethodIDPtr, + broadcastReceiver.reference.pointer, + intentFilter.reference.pointer, + string.reference.pointer, + handler.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_registerReceiver3 = _class.instanceMethodId( + r'registerReceiver', + r'(Landroid/content/BroadcastReceiver;Landroid/content/IntentFilter;Ljava/lang/String;Landroid/os/Handler;I)Landroid/content/Intent;', + ); + + static final _registerReceiver3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + $Int32 + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + + /// from: public abstract android.content.Intent registerReceiver(android.content.BroadcastReceiver broadcastReceiver, android.content.IntentFilter intentFilter, java.lang.String string, android.os.Handler handler, int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject registerReceiver3( + jni.JObject broadcastReceiver, + jni.JObject intentFilter, + jni.JString string, + jni.JObject handler, + int i, + ) { + return _registerReceiver3( + reference.pointer, + _id_registerReceiver3 as jni.JMethodIDPtr, + broadcastReceiver.reference.pointer, + intentFilter.reference.pointer, + string.reference.pointer, + handler.reference.pointer, + i) + .object(const jni.JObjectType()); + } + + static final _id_unregisterReceiver = _class.instanceMethodId( + r'unregisterReceiver', + r'(Landroid/content/BroadcastReceiver;)V', + ); + + static final _unregisterReceiver = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void unregisterReceiver(android.content.BroadcastReceiver broadcastReceiver) + void unregisterReceiver( + jni.JObject broadcastReceiver, + ) { + _unregisterReceiver( + reference.pointer, + _id_unregisterReceiver as jni.JMethodIDPtr, + broadcastReceiver.reference.pointer) + .check(); + } + + static final _id_startService = _class.instanceMethodId( + r'startService', + r'(Landroid/content/Intent;)Landroid/content/ComponentName;', + ); + + static final _startService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract android.content.ComponentName startService(android.content.Intent intent) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject startService( + jni.JObject intent, + ) { + return _startService(reference.pointer, + _id_startService as jni.JMethodIDPtr, intent.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_startForegroundService = _class.instanceMethodId( + r'startForegroundService', + r'(Landroid/content/Intent;)Landroid/content/ComponentName;', + ); + + static final _startForegroundService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract android.content.ComponentName startForegroundService(android.content.Intent intent) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject startForegroundService( + jni.JObject intent, + ) { + return _startForegroundService( + reference.pointer, + _id_startForegroundService as jni.JMethodIDPtr, + intent.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_stopService = _class.instanceMethodId( + r'stopService', + r'(Landroid/content/Intent;)Z', + ); + + static final _stopService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract boolean stopService(android.content.Intent intent) + bool stopService( + jni.JObject intent, + ) { + return _stopService(reference.pointer, _id_stopService as jni.JMethodIDPtr, + intent.reference.pointer) + .boolean; + } + + static final _id_bindService = _class.instanceMethodId( + r'bindService', + r'(Landroid/content/Intent;Landroid/content/ServiceConnection;I)Z', + ); + + static final _bindService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32 + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); + + /// from: public abstract boolean bindService(android.content.Intent intent, android.content.ServiceConnection serviceConnection, int i) + bool bindService( + jni.JObject intent, + jni.JObject serviceConnection, + int i, + ) { + return _bindService(reference.pointer, _id_bindService as jni.JMethodIDPtr, + intent.reference.pointer, serviceConnection.reference.pointer, i) + .boolean; + } + + static final _id_bindService1 = _class.instanceMethodId( + r'bindService', + r'(Landroid/content/Intent;Landroid/content/ServiceConnection;Landroid/content/Context$BindServiceFlags;)Z', + ); + + static final _bindService1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public boolean bindService(android.content.Intent intent, android.content.ServiceConnection serviceConnection, android.content.Context$BindServiceFlags bindServiceFlags) + bool bindService1( + jni.JObject intent, + jni.JObject serviceConnection, + Context_BindServiceFlags bindServiceFlags, + ) { + return _bindService1( + reference.pointer, + _id_bindService1 as jni.JMethodIDPtr, + intent.reference.pointer, + serviceConnection.reference.pointer, + bindServiceFlags.reference.pointer) + .boolean; + } + + static final _id_bindService2 = _class.instanceMethodId( + r'bindService', + r'(Landroid/content/Intent;ILjava/util/concurrent/Executor;Landroid/content/ServiceConnection;)Z', + ); + + static final _bindService2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public boolean bindService(android.content.Intent intent, int i, java.util.concurrent.Executor executor, android.content.ServiceConnection serviceConnection) + bool bindService2( + jni.JObject intent, + int i, + jni.JObject executor, + jni.JObject serviceConnection, + ) { + return _bindService2( + reference.pointer, + _id_bindService2 as jni.JMethodIDPtr, + intent.reference.pointer, + i, + executor.reference.pointer, + serviceConnection.reference.pointer) + .boolean; + } + + static final _id_bindService3 = _class.instanceMethodId( + r'bindService', + r'(Landroid/content/Intent;Landroid/content/Context$BindServiceFlags;Ljava/util/concurrent/Executor;Landroid/content/ServiceConnection;)Z', + ); + + static final _bindService3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public boolean bindService(android.content.Intent intent, android.content.Context$BindServiceFlags bindServiceFlags, java.util.concurrent.Executor executor, android.content.ServiceConnection serviceConnection) + bool bindService3( + jni.JObject intent, + Context_BindServiceFlags bindServiceFlags, + jni.JObject executor, + jni.JObject serviceConnection, + ) { + return _bindService3( + reference.pointer, + _id_bindService3 as jni.JMethodIDPtr, + intent.reference.pointer, + bindServiceFlags.reference.pointer, + executor.reference.pointer, + serviceConnection.reference.pointer) + .boolean; + } + + static final _id_bindIsolatedService = _class.instanceMethodId( + r'bindIsolatedService', + r'(Landroid/content/Intent;ILjava/lang/String;Ljava/util/concurrent/Executor;Landroid/content/ServiceConnection;)Z', + ); + + static final _bindIsolatedService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public boolean bindIsolatedService(android.content.Intent intent, int i, java.lang.String string, java.util.concurrent.Executor executor, android.content.ServiceConnection serviceConnection) + bool bindIsolatedService( + jni.JObject intent, + int i, + jni.JString string, + jni.JObject executor, + jni.JObject serviceConnection, + ) { + return _bindIsolatedService( + reference.pointer, + _id_bindIsolatedService as jni.JMethodIDPtr, + intent.reference.pointer, + i, + string.reference.pointer, + executor.reference.pointer, + serviceConnection.reference.pointer) + .boolean; + } + + static final _id_bindIsolatedService1 = _class.instanceMethodId( + r'bindIsolatedService', + r'(Landroid/content/Intent;Landroid/content/Context$BindServiceFlags;Ljava/lang/String;Ljava/util/concurrent/Executor;Landroid/content/ServiceConnection;)Z', + ); + + static final _bindIsolatedService1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public boolean bindIsolatedService(android.content.Intent intent, android.content.Context$BindServiceFlags bindServiceFlags, java.lang.String string, java.util.concurrent.Executor executor, android.content.ServiceConnection serviceConnection) + bool bindIsolatedService1( + jni.JObject intent, + Context_BindServiceFlags bindServiceFlags, + jni.JString string, + jni.JObject executor, + jni.JObject serviceConnection, + ) { + return _bindIsolatedService1( + reference.pointer, + _id_bindIsolatedService1 as jni.JMethodIDPtr, + intent.reference.pointer, + bindServiceFlags.reference.pointer, + string.reference.pointer, + executor.reference.pointer, + serviceConnection.reference.pointer) + .boolean; + } + + static final _id_bindServiceAsUser = _class.instanceMethodId( + r'bindServiceAsUser', + r'(Landroid/content/Intent;Landroid/content/ServiceConnection;ILandroid/os/UserHandle;)Z', + ); + + static final _bindServiceAsUser = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); + + /// from: public boolean bindServiceAsUser(android.content.Intent intent, android.content.ServiceConnection serviceConnection, int i, android.os.UserHandle userHandle) + bool bindServiceAsUser( + jni.JObject intent, + jni.JObject serviceConnection, + int i, + jni.JObject userHandle, + ) { + return _bindServiceAsUser( + reference.pointer, + _id_bindServiceAsUser as jni.JMethodIDPtr, + intent.reference.pointer, + serviceConnection.reference.pointer, + i, + userHandle.reference.pointer) + .boolean; + } + + static final _id_bindServiceAsUser1 = _class.instanceMethodId( + r'bindServiceAsUser', + r'(Landroid/content/Intent;Landroid/content/ServiceConnection;Landroid/content/Context$BindServiceFlags;Landroid/os/UserHandle;)Z', + ); + + static final _bindServiceAsUser1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public boolean bindServiceAsUser(android.content.Intent intent, android.content.ServiceConnection serviceConnection, android.content.Context$BindServiceFlags bindServiceFlags, android.os.UserHandle userHandle) + bool bindServiceAsUser1( + jni.JObject intent, + jni.JObject serviceConnection, + Context_BindServiceFlags bindServiceFlags, + jni.JObject userHandle, + ) { + return _bindServiceAsUser1( + reference.pointer, + _id_bindServiceAsUser1 as jni.JMethodIDPtr, + intent.reference.pointer, + serviceConnection.reference.pointer, + bindServiceFlags.reference.pointer, + userHandle.reference.pointer) + .boolean; + } + + static final _id_updateServiceGroup = _class.instanceMethodId( + r'updateServiceGroup', + r'(Landroid/content/ServiceConnection;II)V', + ); + + static final _updateServiceGroup = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int)>(); + + /// from: public void updateServiceGroup(android.content.ServiceConnection serviceConnection, int i, int i1) + void updateServiceGroup( + jni.JObject serviceConnection, + int i, + int i1, + ) { + _updateServiceGroup( + reference.pointer, + _id_updateServiceGroup as jni.JMethodIDPtr, + serviceConnection.reference.pointer, + i, + i1) + .check(); + } + + static final _id_unbindService = _class.instanceMethodId( + r'unbindService', + r'(Landroid/content/ServiceConnection;)V', + ); + + static final _unbindService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract void unbindService(android.content.ServiceConnection serviceConnection) + void unbindService( + jni.JObject serviceConnection, + ) { + _unbindService(reference.pointer, _id_unbindService as jni.JMethodIDPtr, + serviceConnection.reference.pointer) + .check(); + } + + static final _id_startInstrumentation = _class.instanceMethodId( + r'startInstrumentation', + r'(Landroid/content/ComponentName;Ljava/lang/String;Landroid/os/Bundle;)Z', + ); + + static final _startInstrumentation = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: public abstract boolean startInstrumentation(android.content.ComponentName componentName, java.lang.String string, android.os.Bundle bundle) + bool startInstrumentation( + jni.JObject componentName, + jni.JString string, + Bundle bundle, + ) { + return _startInstrumentation( + reference.pointer, + _id_startInstrumentation as jni.JMethodIDPtr, + componentName.reference.pointer, + string.reference.pointer, + bundle.reference.pointer) + .boolean; + } + + static final _id_getSystemService = _class.instanceMethodId( + r'getSystemService', + r'(Ljava/lang/String;)Ljava/lang/Object;', + ); + + static final _getSystemService = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract java.lang.Object getSystemService(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSystemService( + jni.JString string, + ) { + return _getSystemService(reference.pointer, + _id_getSystemService as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getSystemService1 = _class.instanceMethodId( + r'getSystemService', + r'(Ljava/lang/Class;)Ljava/lang/Object;', + ); + + static final _getSystemService1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public final T getSystemService(java.lang.Class class) + /// The returned object must be released after use, by calling the [release] method. + $T getSystemService1<$T extends jni.JObject>( + jni.JObject class0, { + required jni.JObjType<$T> T, + }) { + return _getSystemService1(reference.pointer, + _id_getSystemService1 as jni.JMethodIDPtr, class0.reference.pointer) + .object(T); + } + + static final _id_getSystemServiceName = _class.instanceMethodId( + r'getSystemServiceName', + r'(Ljava/lang/Class;)Ljava/lang/String;', + ); + + static final _getSystemServiceName = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract java.lang.String getSystemServiceName(java.lang.Class class) + /// The returned object must be released after use, by calling the [release] method. + jni.JString getSystemServiceName( + jni.JObject class0, + ) { + return _getSystemServiceName( + reference.pointer, + _id_getSystemServiceName as jni.JMethodIDPtr, + class0.reference.pointer) + .object(const jni.JStringType()); + } + + static final _id_checkPermission = _class.instanceMethodId( + r'checkPermission', + r'(Ljava/lang/String;II)I', + ); + + static final _checkPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32, $Int32)>)>>( + 'globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int)>(); + + /// from: public abstract int checkPermission(java.lang.String string, int i, int i1) + int checkPermission( + jni.JString string, + int i, + int i1, + ) { + return _checkPermission( + reference.pointer, + _id_checkPermission as jni.JMethodIDPtr, + string.reference.pointer, + i, + i1) + .integer; + } + + static final _id_checkCallingPermission = _class.instanceMethodId( + r'checkCallingPermission', + r'(Ljava/lang/String;)I', + ); + + static final _checkCallingPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract int checkCallingPermission(java.lang.String string) + int checkCallingPermission( + jni.JString string, + ) { + return _checkCallingPermission( + reference.pointer, + _id_checkCallingPermission as jni.JMethodIDPtr, + string.reference.pointer) + .integer; + } + + static final _id_checkCallingOrSelfPermission = _class.instanceMethodId( + r'checkCallingOrSelfPermission', + r'(Ljava/lang/String;)I', + ); + + static final _checkCallingOrSelfPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract int checkCallingOrSelfPermission(java.lang.String string) + int checkCallingOrSelfPermission( + jni.JString string, + ) { + return _checkCallingOrSelfPermission( + reference.pointer, + _id_checkCallingOrSelfPermission as jni.JMethodIDPtr, + string.reference.pointer) + .integer; + } + + static final _id_checkSelfPermission = _class.instanceMethodId( + r'checkSelfPermission', + r'(Ljava/lang/String;)I', + ); + + static final _checkSelfPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract int checkSelfPermission(java.lang.String string) + int checkSelfPermission( + jni.JString string, + ) { + return _checkSelfPermission( + reference.pointer, + _id_checkSelfPermission as jni.JMethodIDPtr, + string.reference.pointer) + .integer; + } + + static final _id_enforcePermission = _class.instanceMethodId( + r'enforcePermission', + r'(Ljava/lang/String;IILjava/lang/String;)V', + ); + + static final _enforcePermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int, ffi.Pointer)>(); + + /// from: public abstract void enforcePermission(java.lang.String string, int i, int i1, java.lang.String string1) + void enforcePermission( + jni.JString string, + int i, + int i1, + jni.JString string1, + ) { + _enforcePermission( + reference.pointer, + _id_enforcePermission as jni.JMethodIDPtr, + string.reference.pointer, + i, + i1, + string1.reference.pointer) + .check(); + } + + static final _id_enforceCallingPermission = _class.instanceMethodId( + r'enforceCallingPermission', + r'(Ljava/lang/String;Ljava/lang/String;)V', + ); + + static final _enforceCallingPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract void enforceCallingPermission(java.lang.String string, java.lang.String string1) + void enforceCallingPermission( + jni.JString string, + jni.JString string1, + ) { + _enforceCallingPermission( + reference.pointer, + _id_enforceCallingPermission as jni.JMethodIDPtr, + string.reference.pointer, + string1.reference.pointer) + .check(); + } + + static final _id_enforceCallingOrSelfPermission = _class.instanceMethodId( + r'enforceCallingOrSelfPermission', + r'(Ljava/lang/String;Ljava/lang/String;)V', + ); + + static final _enforceCallingOrSelfPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public abstract void enforceCallingOrSelfPermission(java.lang.String string, java.lang.String string1) + void enforceCallingOrSelfPermission( + jni.JString string, + jni.JString string1, + ) { + _enforceCallingOrSelfPermission( + reference.pointer, + _id_enforceCallingOrSelfPermission as jni.JMethodIDPtr, + string.reference.pointer, + string1.reference.pointer) + .check(); + } + + static final _id_grantUriPermission = _class.instanceMethodId( + r'grantUriPermission', + r'(Ljava/lang/String;Landroid/net/Uri;I)V', + ); + + static final _grantUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); + + /// from: public abstract void grantUriPermission(java.lang.String string, android.net.Uri uri, int i) + void grantUriPermission( + jni.JString string, + Uri uri, + int i, + ) { + _grantUriPermission( + reference.pointer, + _id_grantUriPermission as jni.JMethodIDPtr, + string.reference.pointer, + uri.reference.pointer, + i) + .check(); + } + + static final _id_revokeUriPermission = _class.instanceMethodId( + r'revokeUriPermission', + r'(Landroid/net/Uri;I)V', + ); + + static final _revokeUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public abstract void revokeUriPermission(android.net.Uri uri, int i) + void revokeUriPermission( + Uri uri, + int i, + ) { + _revokeUriPermission( + reference.pointer, + _id_revokeUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i) + .check(); + } + + static final _id_revokeUriPermission1 = _class.instanceMethodId( + r'revokeUriPermission', + r'(Ljava/lang/String;Landroid/net/Uri;I)V', + ); + + static final _revokeUriPermission1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + $Int32 + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer, int)>(); + + /// from: public abstract void revokeUriPermission(java.lang.String string, android.net.Uri uri, int i) + void revokeUriPermission1( + jni.JString string, + Uri uri, + int i, + ) { + _revokeUriPermission1( + reference.pointer, + _id_revokeUriPermission1 as jni.JMethodIDPtr, + string.reference.pointer, + uri.reference.pointer, + i) + .check(); + } + + static final _id_checkUriPermission = _class.instanceMethodId( + r'checkUriPermission', + r'(Landroid/net/Uri;III)I', + ); + + static final _checkUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + $Int32, + $Int32 + )>)>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int, int)>(); + + /// from: public abstract int checkUriPermission(android.net.Uri uri, int i, int i1, int i2) + int checkUriPermission( + Uri uri, + int i, + int i1, + int i2, + ) { + return _checkUriPermission( + reference.pointer, + _id_checkUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i, + i1, + i2) + .integer; + } + + static final _id_checkUriPermissions = _class.instanceMethodId( + r'checkUriPermissions', + r'(Ljava/util/List;III)[I', + ); + + static final _checkUriPermissions = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + $Int32, + $Int32 + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int, int)>(); + + /// from: public java.lang.Object[] checkUriPermissions(java.util.List list, int i, int i1, int i2) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray checkUriPermissions( + jni.JList list, + int i, + int i1, + int i2, + ) { + return _checkUriPermissions( + reference.pointer, + _id_checkUriPermissions as jni.JMethodIDPtr, + list.reference.pointer, + i, + i1, + i2) + .object(const jni.JArrayType(jni.jintType())); + } + + static final _id_checkCallingUriPermission = _class.instanceMethodId( + r'checkCallingUriPermission', + r'(Landroid/net/Uri;I)I', + ); + + static final _checkCallingUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public abstract int checkCallingUriPermission(android.net.Uri uri, int i) + int checkCallingUriPermission( + Uri uri, + int i, + ) { + return _checkCallingUriPermission( + reference.pointer, + _id_checkCallingUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i) + .integer; + } + + static final _id_checkCallingUriPermissions = _class.instanceMethodId( + r'checkCallingUriPermissions', + r'(Ljava/util/List;I)[I', + ); + + static final _checkCallingUriPermissions = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public java.lang.Object[] checkCallingUriPermissions(java.util.List list, int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray checkCallingUriPermissions( + jni.JList list, + int i, + ) { + return _checkCallingUriPermissions( + reference.pointer, + _id_checkCallingUriPermissions as jni.JMethodIDPtr, + list.reference.pointer, + i) + .object(const jni.JArrayType(jni.jintType())); + } + + static final _id_checkCallingOrSelfUriPermission = _class.instanceMethodId( + r'checkCallingOrSelfUriPermission', + r'(Landroid/net/Uri;I)I', + ); + + static final _checkCallingOrSelfUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public abstract int checkCallingOrSelfUriPermission(android.net.Uri uri, int i) + int checkCallingOrSelfUriPermission( + Uri uri, + int i, + ) { + return _checkCallingOrSelfUriPermission( + reference.pointer, + _id_checkCallingOrSelfUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i) + .integer; + } + + static final _id_checkCallingOrSelfUriPermissions = _class.instanceMethodId( + r'checkCallingOrSelfUriPermissions', + r'(Ljava/util/List;I)[I', + ); + + static final _checkCallingOrSelfUriPermissions = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public java.lang.Object[] checkCallingOrSelfUriPermissions(java.util.List list, int i) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray checkCallingOrSelfUriPermissions( + jni.JList list, + int i, + ) { + return _checkCallingOrSelfUriPermissions( + reference.pointer, + _id_checkCallingOrSelfUriPermissions as jni.JMethodIDPtr, + list.reference.pointer, + i) + .object(const jni.JArrayType(jni.jintType())); + } + + static final _id_checkUriPermission1 = _class.instanceMethodId( + r'checkUriPermission', + r'(Landroid/net/Uri;Ljava/lang/String;Ljava/lang/String;III)I', + ); + + static final _checkUriPermission1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + $Int32, + $Int32, + $Int32 + )>)>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + int)>(); + + /// from: public abstract int checkUriPermission(android.net.Uri uri, java.lang.String string, java.lang.String string1, int i, int i1, int i2) + int checkUriPermission1( + Uri uri, + jni.JString string, + jni.JString string1, + int i, + int i1, + int i2, + ) { + return _checkUriPermission1( + reference.pointer, + _id_checkUriPermission1 as jni.JMethodIDPtr, + uri.reference.pointer, + string.reference.pointer, + string1.reference.pointer, + i, + i1, + i2) + .integer; + } + + static final _id_enforceUriPermission = _class.instanceMethodId( + r'enforceUriPermission', + r'(Landroid/net/Uri;IIILjava/lang/String;)V', + ); + + static final _enforceUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + $Int32, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, int, int, ffi.Pointer)>(); + + /// from: public abstract void enforceUriPermission(android.net.Uri uri, int i, int i1, int i2, java.lang.String string) + void enforceUriPermission( + Uri uri, + int i, + int i1, + int i2, + jni.JString string, + ) { + _enforceUriPermission( + reference.pointer, + _id_enforceUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i, + i1, + i2, + string.reference.pointer) + .check(); + } + + static final _id_enforceCallingUriPermission = _class.instanceMethodId( + r'enforceCallingUriPermission', + r'(Landroid/net/Uri;ILjava/lang/String;)V', + ); + + static final _enforceCallingUriPermission = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); + + /// from: public abstract void enforceCallingUriPermission(android.net.Uri uri, int i, java.lang.String string) + void enforceCallingUriPermission( + Uri uri, + int i, + jni.JString string, + ) { + _enforceCallingUriPermission( + reference.pointer, + _id_enforceCallingUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i, + string.reference.pointer) + .check(); + } + + static final _id_enforceCallingOrSelfUriPermission = _class.instanceMethodId( + r'enforceCallingOrSelfUriPermission', + r'(Landroid/net/Uri;ILjava/lang/String;)V', + ); + + static final _enforceCallingOrSelfUriPermission = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + int, + ffi.Pointer)>(); + + /// from: public abstract void enforceCallingOrSelfUriPermission(android.net.Uri uri, int i, java.lang.String string) + void enforceCallingOrSelfUriPermission( + Uri uri, + int i, + jni.JString string, + ) { + _enforceCallingOrSelfUriPermission( + reference.pointer, + _id_enforceCallingOrSelfUriPermission as jni.JMethodIDPtr, + uri.reference.pointer, + i, + string.reference.pointer) + .check(); + } + + static final _id_enforceUriPermission1 = _class.instanceMethodId( + r'enforceUriPermission', + r'(Landroid/net/Uri;Ljava/lang/String;Ljava/lang/String;IIILjava/lang/String;)V', + ); + + static final _enforceUriPermission1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + $Int32, + $Int32, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer)>(); + + /// from: public abstract void enforceUriPermission(android.net.Uri uri, java.lang.String string, java.lang.String string1, int i, int i1, int i2, java.lang.String string2) + void enforceUriPermission1( + Uri uri, + jni.JString string, + jni.JString string1, + int i, + int i1, + int i2, + jni.JString string2, + ) { + _enforceUriPermission1( + reference.pointer, + _id_enforceUriPermission1 as jni.JMethodIDPtr, + uri.reference.pointer, + string.reference.pointer, + string1.reference.pointer, + i, + i1, + i2, + string2.reference.pointer) + .check(); + } + + static final _id_revokeSelfPermissionOnKill = _class.instanceMethodId( + r'revokeSelfPermissionOnKill', + r'(Ljava/lang/String;)V', + ); + + static final _revokeSelfPermissionOnKill = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void revokeSelfPermissionOnKill(java.lang.String string) + void revokeSelfPermissionOnKill( + jni.JString string, + ) { + _revokeSelfPermissionOnKill( + reference.pointer, + _id_revokeSelfPermissionOnKill as jni.JMethodIDPtr, + string.reference.pointer) + .check(); + } + + static final _id_revokeSelfPermissionsOnKill = _class.instanceMethodId( + r'revokeSelfPermissionsOnKill', + r'(Ljava/util/Collection;)V', + ); + + static final _revokeSelfPermissionsOnKill = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void revokeSelfPermissionsOnKill(java.util.Collection collection) + void revokeSelfPermissionsOnKill( + jni.JObject collection, + ) { + _revokeSelfPermissionsOnKill( + reference.pointer, + _id_revokeSelfPermissionsOnKill as jni.JMethodIDPtr, + collection.reference.pointer) + .check(); + } + + static final _id_createPackageContext = _class.instanceMethodId( + r'createPackageContext', + r'(Ljava/lang/String;I)Landroid/content/Context;', + ); + + static final _createPackageContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public abstract android.content.Context createPackageContext(java.lang.String string, int i) + /// The returned object must be released after use, by calling the [release] method. + Context createPackageContext( + jni.JString string, + int i, + ) { + return _createPackageContext( + reference.pointer, + _id_createPackageContext as jni.JMethodIDPtr, + string.reference.pointer, + i) + .object(const $ContextType()); + } + + static final _id_createContextForSplit = _class.instanceMethodId( + r'createContextForSplit', + r'(Ljava/lang/String;)Landroid/content/Context;', + ); + + static final _createContextForSplit = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract android.content.Context createContextForSplit(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Context createContextForSplit( + jni.JString string, + ) { + return _createContextForSplit( + reference.pointer, + _id_createContextForSplit as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $ContextType()); + } + + static final _id_createConfigurationContext = _class.instanceMethodId( + r'createConfigurationContext', + r'(Landroid/content/res/Configuration;)Landroid/content/Context;', + ); + + static final _createConfigurationContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract android.content.Context createConfigurationContext(android.content.res.Configuration configuration) + /// The returned object must be released after use, by calling the [release] method. + Context createConfigurationContext( + jni.JObject configuration, + ) { + return _createConfigurationContext( + reference.pointer, + _id_createConfigurationContext as jni.JMethodIDPtr, + configuration.reference.pointer) + .object(const $ContextType()); + } + + static final _id_createDisplayContext = _class.instanceMethodId( + r'createDisplayContext', + r'(Landroid/view/Display;)Landroid/content/Context;', + ); + + static final _createDisplayContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public abstract android.content.Context createDisplayContext(android.view.Display display) + /// The returned object must be released after use, by calling the [release] method. + Context createDisplayContext( + jni.JObject display, + ) { + return _createDisplayContext( + reference.pointer, + _id_createDisplayContext as jni.JMethodIDPtr, + display.reference.pointer) + .object(const $ContextType()); + } + + static final _id_createDeviceContext = _class.instanceMethodId( + r'createDeviceContext', + r'(I)Landroid/content/Context;', + ); + + static final _createDeviceContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public android.content.Context createDeviceContext(int i) + /// The returned object must be released after use, by calling the [release] method. + Context createDeviceContext( + int i, + ) { + return _createDeviceContext( + reference.pointer, _id_createDeviceContext as jni.JMethodIDPtr, i) + .object(const $ContextType()); + } + + static final _id_createWindowContext = _class.instanceMethodId( + r'createWindowContext', + r'(ILandroid/os/Bundle;)Landroid/content/Context;', + ); + + static final _createWindowContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<($Int32, ffi.Pointer)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, int, + ffi.Pointer)>(); + + /// from: public android.content.Context createWindowContext(int i, android.os.Bundle bundle) + /// The returned object must be released after use, by calling the [release] method. + Context createWindowContext( + int i, + Bundle bundle, + ) { + return _createWindowContext( + reference.pointer, + _id_createWindowContext as jni.JMethodIDPtr, + i, + bundle.reference.pointer) + .object(const $ContextType()); + } + + static final _id_createWindowContext1 = _class.instanceMethodId( + r'createWindowContext', + r'(Landroid/view/Display;ILandroid/os/Bundle;)Landroid/content/Context;', + ); + + static final _createWindowContext1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + $Int32, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int, ffi.Pointer)>(); + + /// from: public android.content.Context createWindowContext(android.view.Display display, int i, android.os.Bundle bundle) + /// The returned object must be released after use, by calling the [release] method. + Context createWindowContext1( + jni.JObject display, + int i, + Bundle bundle, + ) { + return _createWindowContext1( + reference.pointer, + _id_createWindowContext1 as jni.JMethodIDPtr, + display.reference.pointer, + i, + bundle.reference.pointer) + .object(const $ContextType()); + } + + static final _id_createContext = _class.instanceMethodId( + r'createContext', + r'(Landroid/content/ContextParams;)Landroid/content/Context;', + ); + + static final _createContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.content.Context createContext(android.content.ContextParams contextParams) + /// The returned object must be released after use, by calling the [release] method. + Context createContext( + jni.JObject contextParams, + ) { + return _createContext( + reference.pointer, + _id_createContext as jni.JMethodIDPtr, + contextParams.reference.pointer) + .object(const $ContextType()); + } + + static final _id_createAttributionContext = _class.instanceMethodId( + r'createAttributionContext', + r'(Ljava/lang/String;)Landroid/content/Context;', + ); + + static final _createAttributionContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.content.Context createAttributionContext(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Context createAttributionContext( + jni.JString string, + ) { + return _createAttributionContext( + reference.pointer, + _id_createAttributionContext as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $ContextType()); + } + + static final _id_createDeviceProtectedStorageContext = + _class.instanceMethodId( + r'createDeviceProtectedStorageContext', + r'()Landroid/content/Context;', + ); + + static final _createDeviceProtectedStorageContext = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.content.Context createDeviceProtectedStorageContext() + /// The returned object must be released after use, by calling the [release] method. + Context createDeviceProtectedStorageContext() { + return _createDeviceProtectedStorageContext(reference.pointer, + _id_createDeviceProtectedStorageContext as jni.JMethodIDPtr) + .object(const $ContextType()); + } + + static final _id_getDisplay = _class.instanceMethodId( + r'getDisplay', + r'()Landroid/view/Display;', + ); + + static final _getDisplay = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.view.Display getDisplay() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getDisplay() { + return _getDisplay(reference.pointer, _id_getDisplay as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_getDeviceId = _class.instanceMethodId( + r'getDeviceId', + r'()I', + ); + + static final _getDeviceId = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int getDeviceId() + int getDeviceId() { + return _getDeviceId(reference.pointer, _id_getDeviceId as jni.JMethodIDPtr) + .integer; + } + + static final _id_registerDeviceIdChangeListener = _class.instanceMethodId( + r'registerDeviceIdChangeListener', + r'(Ljava/util/concurrent/Executor;Ljava/util/function/IntConsumer;)V', + ); + + static final _registerDeviceIdChangeListener = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void registerDeviceIdChangeListener(java.util.concurrent.Executor executor, java.util.function.IntConsumer intConsumer) + void registerDeviceIdChangeListener( + jni.JObject executor, + jni.JObject intConsumer, + ) { + _registerDeviceIdChangeListener( + reference.pointer, + _id_registerDeviceIdChangeListener as jni.JMethodIDPtr, + executor.reference.pointer, + intConsumer.reference.pointer) + .check(); + } + + static final _id_unregisterDeviceIdChangeListener = _class.instanceMethodId( + r'unregisterDeviceIdChangeListener', + r'(Ljava/util/function/IntConsumer;)V', + ); + + static final _unregisterDeviceIdChangeListener = + ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, + jni.JMethodIDPtr, ffi.Pointer)>(); + + /// from: public void unregisterDeviceIdChangeListener(java.util.function.IntConsumer intConsumer) + void unregisterDeviceIdChangeListener( + jni.JObject intConsumer, + ) { + _unregisterDeviceIdChangeListener( + reference.pointer, + _id_unregisterDeviceIdChangeListener as jni.JMethodIDPtr, + intConsumer.reference.pointer) + .check(); + } + + static final _id_isRestricted = _class.instanceMethodId( + r'isRestricted', + r'()Z', + ); + + static final _isRestricted = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isRestricted() + bool isRestricted() { + return _isRestricted( + reference.pointer, _id_isRestricted as jni.JMethodIDPtr) + .boolean; + } + + static final _id_isDeviceProtectedStorage = _class.instanceMethodId( + r'isDeviceProtectedStorage', + r'()Z', + ); + + static final _isDeviceProtectedStorage = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract boolean isDeviceProtectedStorage() + bool isDeviceProtectedStorage() { + return _isDeviceProtectedStorage( + reference.pointer, _id_isDeviceProtectedStorage as jni.JMethodIDPtr) + .boolean; + } + + static final _id_isUiContext = _class.instanceMethodId( + r'isUiContext', + r'()Z', + ); + + static final _isUiContext = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isUiContext() + bool isUiContext() { + return _isUiContext(reference.pointer, _id_isUiContext as jni.JMethodIDPtr) + .boolean; + } +} + +final class $ContextType extends jni.JObjType { + const $ContextType(); + + @override + String get signature => r'Landroid/content/Context;'; + + @override + Context fromReference(jni.JReference reference) => + Context.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($ContextType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($ContextType) && other is $ContextType; + } +} + +/// from: android.net.Uri$Builder +class Uri_Builder extends jni.JObject { + @override + late final jni.JObjType $type = type; + + Uri_Builder.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r'android/net/Uri$Builder'); + + /// The type which includes information such as the signature of this class. + static const type = $Uri_BuilderType(); + static final _id_new0 = _class.constructorId( + r'()V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void () + /// The returned object must be released after use, by calling the [release] method. + factory Uri_Builder() { + return Uri_Builder.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); + } + + static final _id_scheme = _class.instanceMethodId( + r'scheme', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _scheme = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder scheme(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder scheme( + jni.JString string, + ) { + return _scheme(reference.pointer, _id_scheme as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_opaquePart = _class.instanceMethodId( + r'opaquePart', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _opaquePart = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder opaquePart(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder opaquePart( + jni.JString string, + ) { + return _opaquePart(reference.pointer, _id_opaquePart as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_encodedOpaquePart = _class.instanceMethodId( + r'encodedOpaquePart', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _encodedOpaquePart = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder encodedOpaquePart(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder encodedOpaquePart( + jni.JString string, + ) { + return _encodedOpaquePart(reference.pointer, + _id_encodedOpaquePart as jni.JMethodIDPtr, string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_authority = _class.instanceMethodId( + r'authority', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _authority = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder authority(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder authority( + jni.JString string, + ) { + return _authority(reference.pointer, _id_authority as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_encodedAuthority = _class.instanceMethodId( + r'encodedAuthority', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _encodedAuthority = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder encodedAuthority(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder encodedAuthority( + jni.JString string, + ) { + return _encodedAuthority(reference.pointer, + _id_encodedAuthority as jni.JMethodIDPtr, string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_path = _class.instanceMethodId( + r'path', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _path = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder path(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder path( + jni.JString string, + ) { + return _path(reference.pointer, _id_path as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_encodedPath = _class.instanceMethodId( + r'encodedPath', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _encodedPath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder encodedPath(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder encodedPath( + jni.JString string, + ) { + return _encodedPath(reference.pointer, _id_encodedPath as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_appendPath = _class.instanceMethodId( + r'appendPath', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _appendPath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder appendPath(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder appendPath( + jni.JString string, + ) { + return _appendPath(reference.pointer, _id_appendPath as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_appendEncodedPath = _class.instanceMethodId( + r'appendEncodedPath', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _appendEncodedPath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder appendEncodedPath(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder appendEncodedPath( + jni.JString string, + ) { + return _appendEncodedPath(reference.pointer, + _id_appendEncodedPath as jni.JMethodIDPtr, string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_query = _class.instanceMethodId( + r'query', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _query = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder query(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder query( + jni.JString string, + ) { + return _query(reference.pointer, _id_query as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_encodedQuery = _class.instanceMethodId( + r'encodedQuery', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _encodedQuery = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder encodedQuery(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder encodedQuery( + jni.JString string, + ) { + return _encodedQuery(reference.pointer, + _id_encodedQuery as jni.JMethodIDPtr, string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_fragment = _class.instanceMethodId( + r'fragment', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _fragment = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder fragment(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder fragment( + jni.JString string, + ) { + return _fragment(reference.pointer, _id_fragment as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_encodedFragment = _class.instanceMethodId( + r'encodedFragment', + r'(Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _encodedFragment = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder encodedFragment(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder encodedFragment( + jni.JString string, + ) { + return _encodedFragment(reference.pointer, + _id_encodedFragment as jni.JMethodIDPtr, string.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_appendQueryParameter = _class.instanceMethodId( + r'appendQueryParameter', + r'(Ljava/lang/String;Ljava/lang/String;)Landroid/net/Uri$Builder;', + ); + + static final _appendQueryParameter = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public android.net.Uri$Builder appendQueryParameter(java.lang.String string, java.lang.String string1) + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder appendQueryParameter( + jni.JString string, + jni.JString string1, + ) { + return _appendQueryParameter( + reference.pointer, + _id_appendQueryParameter as jni.JMethodIDPtr, + string.reference.pointer, + string1.reference.pointer) + .object(const $Uri_BuilderType()); + } + + static final _id_clearQuery = _class.instanceMethodId( + r'clearQuery', + r'()Landroid/net/Uri$Builder;', + ); + + static final _clearQuery = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.net.Uri$Builder clearQuery() + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder clearQuery() { + return _clearQuery(reference.pointer, _id_clearQuery as jni.JMethodIDPtr) + .object(const $Uri_BuilderType()); + } + + static final _id_build = _class.instanceMethodId( + r'build', + r'()Landroid/net/Uri;', + ); + + static final _build = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.net.Uri build() + /// The returned object must be released after use, by calling the [release] method. + Uri build() { + return _build(reference.pointer, _id_build as jni.JMethodIDPtr) + .object(const $UriType()); + } + + static final _id_toString1 = _class.instanceMethodId( + r'toString', + r'()Ljava/lang/String;', + ); + + static final _toString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String toString() + /// The returned object must be released after use, by calling the [release] method. + jni.JString toString1() { + return _toString1(reference.pointer, _id_toString1 as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } +} + +final class $Uri_BuilderType extends jni.JObjType { + const $Uri_BuilderType(); + + @override + String get signature => r'Landroid/net/Uri$Builder;'; + + @override + Uri_Builder fromReference(jni.JReference reference) => + Uri_Builder.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($Uri_BuilderType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($Uri_BuilderType) && other is $Uri_BuilderType; + } +} + +/// from: android.net.Uri +class Uri extends jni.JObject { + @override + late final jni.JObjType $type = type; + + Uri.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r'android/net/Uri'); + + /// The type which includes information such as the signature of this class. + static const type = $UriType(); + static final _id_CREATOR = _class.staticFieldId( + r'CREATOR', + r'Landroid/os/Parcelable$Creator;', + ); + + /// from: static public final android.os.Parcelable$Creator CREATOR + /// The returned object must be released after use, by calling the [release] method. + static jni.JObject get CREATOR => + _id_CREATOR.get(_class, const jni.JObjectType()); + + static final _id_EMPTY = _class.staticFieldId( + r'EMPTY', + r'Landroid/net/Uri;', + ); + + /// from: static public final android.net.Uri EMPTY + /// The returned object must be released after use, by calling the [release] method. + static Uri get EMPTY => _id_EMPTY.get(_class, const $UriType()); + + static final _id_isHierarchical = _class.instanceMethodId( + r'isHierarchical', + r'()Z', + ); + + static final _isHierarchical = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract boolean isHierarchical() + bool isHierarchical() { + return _isHierarchical( + reference.pointer, _id_isHierarchical as jni.JMethodIDPtr) + .boolean; + } + + static final _id_isOpaque = _class.instanceMethodId( + r'isOpaque', + r'()Z', + ); + + static final _isOpaque = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isOpaque() + bool isOpaque() { + return _isOpaque(reference.pointer, _id_isOpaque as jni.JMethodIDPtr) + .boolean; + } + + static final _id_isRelative = _class.instanceMethodId( + r'isRelative', + r'()Z', + ); + + static final _isRelative = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract boolean isRelative() + bool isRelative() { + return _isRelative(reference.pointer, _id_isRelative as jni.JMethodIDPtr) + .boolean; + } + + static final _id_isAbsolute = _class.instanceMethodId( + r'isAbsolute', + r'()Z', + ); + + static final _isAbsolute = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isAbsolute() + bool isAbsolute() { + return _isAbsolute(reference.pointer, _id_isAbsolute as jni.JMethodIDPtr) + .boolean; + } + + static final _id_getScheme = _class.instanceMethodId( + r'getScheme', + r'()Ljava/lang/String;', + ); + + static final _getScheme = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getScheme() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getScheme() { + return _getScheme(reference.pointer, _id_getScheme as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getSchemeSpecificPart = _class.instanceMethodId( + r'getSchemeSpecificPart', + r'()Ljava/lang/String;', + ); + + static final _getSchemeSpecificPart = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getSchemeSpecificPart() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getSchemeSpecificPart() { + return _getSchemeSpecificPart( + reference.pointer, _id_getSchemeSpecificPart as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getEncodedSchemeSpecificPart = _class.instanceMethodId( + r'getEncodedSchemeSpecificPart', + r'()Ljava/lang/String;', + ); + + static final _getEncodedSchemeSpecificPart = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getEncodedSchemeSpecificPart() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getEncodedSchemeSpecificPart() { + return _getEncodedSchemeSpecificPart(reference.pointer, + _id_getEncodedSchemeSpecificPart as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getAuthority = _class.instanceMethodId( + r'getAuthority', + r'()Ljava/lang/String;', + ); + + static final _getAuthority = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getAuthority() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getAuthority() { + return _getAuthority( + reference.pointer, _id_getAuthority as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getEncodedAuthority = _class.instanceMethodId( + r'getEncodedAuthority', + r'()Ljava/lang/String;', + ); + + static final _getEncodedAuthority = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getEncodedAuthority() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getEncodedAuthority() { + return _getEncodedAuthority( + reference.pointer, _id_getEncodedAuthority as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getUserInfo = _class.instanceMethodId( + r'getUserInfo', + r'()Ljava/lang/String;', + ); + + static final _getUserInfo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getUserInfo() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getUserInfo() { + return _getUserInfo(reference.pointer, _id_getUserInfo as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getEncodedUserInfo = _class.instanceMethodId( + r'getEncodedUserInfo', + r'()Ljava/lang/String;', + ); + + static final _getEncodedUserInfo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getEncodedUserInfo() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getEncodedUserInfo() { + return _getEncodedUserInfo( + reference.pointer, _id_getEncodedUserInfo as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getHost = _class.instanceMethodId( + r'getHost', + r'()Ljava/lang/String;', + ); + + static final _getHost = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getHost() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getHost() { + return _getHost(reference.pointer, _id_getHost as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getPort = _class.instanceMethodId( + r'getPort', + r'()I', + ); + + static final _getPort = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract int getPort() + int getPort() { + return _getPort(reference.pointer, _id_getPort as jni.JMethodIDPtr).integer; + } + + static final _id_getPath = _class.instanceMethodId( + r'getPath', + r'()Ljava/lang/String;', + ); + + static final _getPath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getPath() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getPath() { + return _getPath(reference.pointer, _id_getPath as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getEncodedPath = _class.instanceMethodId( + r'getEncodedPath', + r'()Ljava/lang/String;', + ); + + static final _getEncodedPath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getEncodedPath() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getEncodedPath() { + return _getEncodedPath( + reference.pointer, _id_getEncodedPath as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getQuery = _class.instanceMethodId( + r'getQuery', + r'()Ljava/lang/String;', + ); + + static final _getQuery = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getQuery() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getQuery() { + return _getQuery(reference.pointer, _id_getQuery as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getEncodedQuery = _class.instanceMethodId( + r'getEncodedQuery', + r'()Ljava/lang/String;', + ); + + static final _getEncodedQuery = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getEncodedQuery() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getEncodedQuery() { + return _getEncodedQuery( + reference.pointer, _id_getEncodedQuery as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getFragment = _class.instanceMethodId( + r'getFragment', + r'()Ljava/lang/String;', + ); + + static final _getFragment = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getFragment() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getFragment() { + return _getFragment(reference.pointer, _id_getFragment as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getEncodedFragment = _class.instanceMethodId( + r'getEncodedFragment', + r'()Ljava/lang/String;', + ); + + static final _getEncodedFragment = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getEncodedFragment() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getEncodedFragment() { + return _getEncodedFragment( + reference.pointer, _id_getEncodedFragment as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_getPathSegments = _class.instanceMethodId( + r'getPathSegments', + r'()Ljava/util/List;', + ); + + static final _getPathSegments = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.util.List getPathSegments() + /// The returned object must be released after use, by calling the [release] method. + jni.JList getPathSegments() { + return _getPathSegments( + reference.pointer, _id_getPathSegments as jni.JMethodIDPtr) + .object(const jni.JListType(jni.JStringType())); + } + + static final _id_getLastPathSegment = _class.instanceMethodId( + r'getLastPathSegment', + r'()Ljava/lang/String;', + ); + + static final _getLastPathSegment = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String getLastPathSegment() + /// The returned object must be released after use, by calling the [release] method. + jni.JString getLastPathSegment() { + return _getLastPathSegment( + reference.pointer, _id_getLastPathSegment as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_equals = _class.instanceMethodId( + r'equals', + r'(Ljava/lang/Object;)Z', + ); + + static final _equals = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public boolean equals(java.lang.Object object) + bool equals( + jni.JObject object, + ) { + return _equals(reference.pointer, _id_equals as jni.JMethodIDPtr, + object.reference.pointer) + .boolean; + } + + static final _id_hashCode1 = _class.instanceMethodId( + r'hashCode', + r'()I', + ); + + static final _hashCode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int hashCode() + int hashCode1() { + return _hashCode1(reference.pointer, _id_hashCode1 as jni.JMethodIDPtr) + .integer; + } + + static final _id_compareTo = _class.instanceMethodId( + r'compareTo', + r'(Landroid/net/Uri;)I', + ); + + static final _compareTo = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public int compareTo(android.net.Uri uri) + int compareTo( + Uri uri, + ) { + return _compareTo(reference.pointer, _id_compareTo as jni.JMethodIDPtr, + uri.reference.pointer) + .integer; + } + + static final _id_toString1 = _class.instanceMethodId( + r'toString', + r'()Ljava/lang/String;', + ); + + static final _toString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract java.lang.String toString() + /// The returned object must be released after use, by calling the [release] method. + jni.JString toString1() { + return _toString1(reference.pointer, _id_toString1 as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } + + static final _id_buildUpon = _class.instanceMethodId( + r'buildUpon', + r'()Landroid/net/Uri$Builder;', + ); + + static final _buildUpon = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract android.net.Uri$Builder buildUpon() + /// The returned object must be released after use, by calling the [release] method. + Uri_Builder buildUpon() { + return _buildUpon(reference.pointer, _id_buildUpon as jni.JMethodIDPtr) + .object(const $Uri_BuilderType()); + } + + static final _id_parse = _class.staticMethodId( + r'parse', + r'(Ljava/lang/String;)Landroid/net/Uri;', + ); + + static final _parse = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: static public android.net.Uri parse(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + static Uri parse( + jni.JString string, + ) { + return _parse(_class.reference.pointer, _id_parse as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $UriType()); + } + + static final _id_fromFile = _class.staticMethodId( + r'fromFile', + r'(Ljava/io/File;)Landroid/net/Uri;', + ); + + static final _fromFile = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: static public android.net.Uri fromFile(java.io.File file) + /// The returned object must be released after use, by calling the [release] method. + static Uri fromFile( + jni.JObject file, + ) { + return _fromFile(_class.reference.pointer, _id_fromFile as jni.JMethodIDPtr, + file.reference.pointer) + .object(const $UriType()); + } + + static final _id_fromParts = _class.staticMethodId( + r'fromParts', + r'(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)Landroid/net/Uri;', + ); + + static final _fromParts = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + /// from: static public android.net.Uri fromParts(java.lang.String string, java.lang.String string1, java.lang.String string2) + /// The returned object must be released after use, by calling the [release] method. + static Uri fromParts( + jni.JString string, + jni.JString string1, + jni.JString string2, + ) { + return _fromParts( + _class.reference.pointer, + _id_fromParts as jni.JMethodIDPtr, + string.reference.pointer, + string1.reference.pointer, + string2.reference.pointer) + .object(const $UriType()); + } + + static final _id_getQueryParameterNames = _class.instanceMethodId( + r'getQueryParameterNames', + r'()Ljava/util/Set;', + ); + + static final _getQueryParameterNames = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.util.Set getQueryParameterNames() + /// The returned object must be released after use, by calling the [release] method. + jni.JSet getQueryParameterNames() { + return _getQueryParameterNames( + reference.pointer, _id_getQueryParameterNames as jni.JMethodIDPtr) + .object(const jni.JSetType(jni.JStringType())); + } + + static final _id_getQueryParameters = _class.instanceMethodId( + r'getQueryParameters', + r'(Ljava/lang/String;)Ljava/util/List;', + ); + + static final _getQueryParameters = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.util.List getQueryParameters(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JList getQueryParameters( + jni.JString string, + ) { + return _getQueryParameters( + reference.pointer, + _id_getQueryParameters as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JListType(jni.JStringType())); + } + + static final _id_getQueryParameter = _class.instanceMethodId( + r'getQueryParameter', + r'(Ljava/lang/String;)Ljava/lang/String;', + ); + + static final _getQueryParameter = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.lang.String getQueryParameter(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JString getQueryParameter( + jni.JString string, + ) { + return _getQueryParameter(reference.pointer, + _id_getQueryParameter as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JStringType()); + } + + static final _id_getBooleanQueryParameter = _class.instanceMethodId( + r'getBooleanQueryParameter', + r'(Ljava/lang/String;Z)Z', + ); + + static final _getBooleanQueryParameter = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public boolean getBooleanQueryParameter(java.lang.String string, boolean z) + bool getBooleanQueryParameter( + jni.JString string, + bool z, + ) { + return _getBooleanQueryParameter( + reference.pointer, + _id_getBooleanQueryParameter as jni.JMethodIDPtr, + string.reference.pointer, + z ? 1 : 0) + .boolean; + } + + static final _id_normalizeScheme = _class.instanceMethodId( + r'normalizeScheme', + r'()Landroid/net/Uri;', + ); + + static final _normalizeScheme = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.net.Uri normalizeScheme() + /// The returned object must be released after use, by calling the [release] method. + Uri normalizeScheme() { + return _normalizeScheme( + reference.pointer, _id_normalizeScheme as jni.JMethodIDPtr) + .object(const $UriType()); + } + + static final _id_writeToParcel = _class.staticMethodId( + r'writeToParcel', + r'(Landroid/os/Parcel;Landroid/net/Uri;)V', + ); + + static final _writeToParcel = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallStaticVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: static public void writeToParcel(android.os.Parcel parcel, android.net.Uri uri) + static void writeToParcel( + jni.JObject parcel, + Uri uri, + ) { + _writeToParcel( + _class.reference.pointer, + _id_writeToParcel as jni.JMethodIDPtr, + parcel.reference.pointer, + uri.reference.pointer) + .check(); + } + + static final _id_encode = _class.staticMethodId( + r'encode', + r'(Ljava/lang/String;)Ljava/lang/String;', + ); + + static final _encode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: static public java.lang.String encode(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + static jni.JString encode( + jni.JString string, + ) { + return _encode(_class.reference.pointer, _id_encode as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JStringType()); + } + + static final _id_encode1 = _class.staticMethodId( + r'encode', + r'(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;', + ); + + static final _encode1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: static public java.lang.String encode(java.lang.String string, java.lang.String string1) + /// The returned object must be released after use, by calling the [release] method. + static jni.JString encode1( + jni.JString string, + jni.JString string1, + ) { + return _encode1(_class.reference.pointer, _id_encode1 as jni.JMethodIDPtr, + string.reference.pointer, string1.reference.pointer) + .object(const jni.JStringType()); + } + + static final _id_decode = _class.staticMethodId( + r'decode', + r'(Ljava/lang/String;)Ljava/lang/String;', + ); + + static final _decode = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: static public java.lang.String decode(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + static jni.JString decode( + jni.JString string, + ) { + return _decode(_class.reference.pointer, _id_decode as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JStringType()); + } + + static final _id_withAppendedPath = _class.staticMethodId( + r'withAppendedPath', + r'(Landroid/net/Uri;Ljava/lang/String;)Landroid/net/Uri;', + ); + + static final _withAppendedPath = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallStaticObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: static public android.net.Uri withAppendedPath(android.net.Uri uri, java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + static Uri withAppendedPath( + Uri uri, + jni.JString string, + ) { + return _withAppendedPath( + _class.reference.pointer, + _id_withAppendedPath as jni.JMethodIDPtr, + uri.reference.pointer, + string.reference.pointer) + .object(const $UriType()); + } + + static final _id_compareTo1 = _class.instanceMethodId( + r'compareTo', + r'(Ljava/lang/Object;)I', + ); + + static final _compareTo1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public int compareTo(java.lang.Object object) + int compareTo1( + jni.JObject object, + ) { + return _compareTo1(reference.pointer, _id_compareTo1 as jni.JMethodIDPtr, + object.reference.pointer) + .integer; + } +} + +final class $UriType extends jni.JObjType { + const $UriType(); + + @override + String get signature => r'Landroid/net/Uri;'; + + @override + Uri fromReference(jni.JReference reference) => Uri.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($UriType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($UriType) && other is $UriType; + } +} + +/// from: android.os.Bundle +class Bundle extends jni.JObject { + @override + late final jni.JObjType $type = type; + + Bundle.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r'android/os/Bundle'); + + /// The type which includes information such as the signature of this class. + static const type = $BundleType(); + static final _id_CREATOR = _class.staticFieldId( + r'CREATOR', + r'Landroid/os/Parcelable$Creator;', + ); + + /// from: static public final android.os.Parcelable$Creator CREATOR + /// The returned object must be released after use, by calling the [release] method. + static jni.JObject get CREATOR => + _id_CREATOR.get(_class, const jni.JObjectType()); + + static final _id_EMPTY = _class.staticFieldId( + r'EMPTY', + r'Landroid/os/Bundle;', + ); + + /// from: static public final android.os.Bundle EMPTY + /// The returned object must be released after use, by calling the [release] method. + static Bundle get EMPTY => _id_EMPTY.get(_class, const $BundleType()); + + static final _id_new0 = _class.constructorId( + r'()V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void () + /// The returned object must be released after use, by calling the [release] method. + factory Bundle() { + return Bundle.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); + } + + static final _id_new1 = _class.constructorId( + r'(Ljava/lang/ClassLoader;)V', + ); + + static final _new1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void (java.lang.ClassLoader classLoader) + /// The returned object must be released after use, by calling the [release] method. + factory Bundle.new1( + jni.JObject classLoader, + ) { + return Bundle.fromReference(_new1(_class.reference.pointer, + _id_new1 as jni.JMethodIDPtr, classLoader.reference.pointer) + .reference); + } + + static final _id_new2 = _class.constructorId( + r'(I)V', + ); + + static final _new2 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.VarArgs<($Int32,)>)>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, jni.JMethodIDPtr, int)>(); + + /// from: public void (int i) + /// The returned object must be released after use, by calling the [release] method. + factory Bundle.new2( + int i, + ) { + return Bundle.fromReference( + _new2(_class.reference.pointer, _id_new2 as jni.JMethodIDPtr, i) + .reference); + } + + static final _id_new3 = _class.constructorId( + r'(Landroid/os/Bundle;)V', + ); + + static final _new3 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void (android.os.Bundle bundle) + /// The returned object must be released after use, by calling the [release] method. + factory Bundle.new3( + Bundle bundle, + ) { + return Bundle.fromReference(_new3(_class.reference.pointer, + _id_new3 as jni.JMethodIDPtr, bundle.reference.pointer) + .reference); + } + + static final _id_new4 = _class.constructorId( + r'(Landroid/os/PersistableBundle;)V', + ); + + static final _new4 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_NewObject') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void (android.os.PersistableBundle persistableBundle) + /// The returned object must be released after use, by calling the [release] method. + factory Bundle.new4( + jni.JObject persistableBundle, + ) { + return Bundle.fromReference(_new4(_class.reference.pointer, + _id_new4 as jni.JMethodIDPtr, persistableBundle.reference.pointer) + .reference); + } + + static final _id_setClassLoader = _class.instanceMethodId( + r'setClassLoader', + r'(Ljava/lang/ClassLoader;)V', + ); + + static final _setClassLoader = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setClassLoader(java.lang.ClassLoader classLoader) + void setClassLoader( + jni.JObject classLoader, + ) { + _setClassLoader(reference.pointer, _id_setClassLoader as jni.JMethodIDPtr, + classLoader.reference.pointer) + .check(); + } + + static final _id_getClassLoader = _class.instanceMethodId( + r'getClassLoader', + r'()Ljava/lang/ClassLoader;', + ); + + static final _getClassLoader = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.ClassLoader getClassLoader() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getClassLoader() { + return _getClassLoader( + reference.pointer, _id_getClassLoader as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_clone = _class.instanceMethodId( + r'clone', + r'()Ljava/lang/Object;', + ); + + static final _clone = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.Object clone() + /// The returned object must be released after use, by calling the [release] method. + jni.JObject clone() { + return _clone(reference.pointer, _id_clone as jni.JMethodIDPtr) + .object(const jni.JObjectType()); + } + + static final _id_deepCopy = _class.instanceMethodId( + r'deepCopy', + r'()Landroid/os/Bundle;', + ); + + static final _deepCopy = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public android.os.Bundle deepCopy() + /// The returned object must be released after use, by calling the [release] method. + Bundle deepCopy() { + return _deepCopy(reference.pointer, _id_deepCopy as jni.JMethodIDPtr) + .object(const $BundleType()); + } + + static final _id_clear = _class.instanceMethodId( + r'clear', + r'()V', + ); + + static final _clear = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void clear() + void clear() { + _clear(reference.pointer, _id_clear as jni.JMethodIDPtr).check(); + } + + static final _id_remove = _class.instanceMethodId( + r'remove', + r'(Ljava/lang/String;)V', + ); + + static final _remove = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void remove(java.lang.String string) + void remove( + jni.JString string, + ) { + _remove(reference.pointer, _id_remove as jni.JMethodIDPtr, + string.reference.pointer) + .check(); + } + + static final _id_putAll = _class.instanceMethodId( + r'putAll', + r'(Landroid/os/Bundle;)V', + ); + + static final _putAll = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void putAll(android.os.Bundle bundle) + void putAll( + Bundle bundle, + ) { + _putAll(reference.pointer, _id_putAll as jni.JMethodIDPtr, + bundle.reference.pointer) + .check(); + } + + static final _id_hasFileDescriptors = _class.instanceMethodId( + r'hasFileDescriptors', + r'()Z', + ); + + static final _hasFileDescriptors = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean hasFileDescriptors() + bool hasFileDescriptors() { + return _hasFileDescriptors( + reference.pointer, _id_hasFileDescriptors as jni.JMethodIDPtr) + .boolean; + } + + static final _id_putByte = _class.instanceMethodId( + r'putByte', + r'(Ljava/lang/String;B)V', + ); + + static final _putByte = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public void putByte(java.lang.String string, byte b) + void putByte( + jni.JString string, + int b, + ) { + _putByte(reference.pointer, _id_putByte as jni.JMethodIDPtr, + string.reference.pointer, b) + .check(); + } + + static final _id_putChar = _class.instanceMethodId( + r'putChar', + r'(Ljava/lang/String;C)V', + ); + + static final _putChar = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public void putChar(java.lang.String string, char c) + void putChar( + jni.JString string, + int c, + ) { + _putChar(reference.pointer, _id_putChar as jni.JMethodIDPtr, + string.reference.pointer, c) + .check(); + } + + static final _id_putShort = _class.instanceMethodId( + r'putShort', + r'(Ljava/lang/String;S)V', + ); + + static final _putShort = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public void putShort(java.lang.String string, short s) + void putShort( + jni.JString string, + int s, + ) { + _putShort(reference.pointer, _id_putShort as jni.JMethodIDPtr, + string.reference.pointer, s) + .check(); + } + + static final _id_putFloat = _class.instanceMethodId( + r'putFloat', + r'(Ljava/lang/String;F)V', + ); + + static final _putFloat = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Double)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, double)>(); + + /// from: public void putFloat(java.lang.String string, float f) + void putFloat( + jni.JString string, + double f, + ) { + _putFloat(reference.pointer, _id_putFloat as jni.JMethodIDPtr, + string.reference.pointer, f) + .check(); + } + + static final _id_putCharSequence = _class.instanceMethodId( + r'putCharSequence', + r'(Ljava/lang/String;Ljava/lang/CharSequence;)V', + ); + + static final _putCharSequence = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putCharSequence(java.lang.String string, java.lang.CharSequence charSequence) + void putCharSequence( + jni.JString string, + jni.JObject charSequence, + ) { + _putCharSequence(reference.pointer, _id_putCharSequence as jni.JMethodIDPtr, + string.reference.pointer, charSequence.reference.pointer) + .check(); + } + + static final _id_putParcelable = _class.instanceMethodId( + r'putParcelable', + r'(Ljava/lang/String;Landroid/os/Parcelable;)V', + ); + + static final _putParcelable = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putParcelable(java.lang.String string, android.os.Parcelable parcelable) + void putParcelable( + jni.JString string, + jni.JObject parcelable, + ) { + _putParcelable(reference.pointer, _id_putParcelable as jni.JMethodIDPtr, + string.reference.pointer, parcelable.reference.pointer) + .check(); + } + + static final _id_putSize = _class.instanceMethodId( + r'putSize', + r'(Ljava/lang/String;Landroid/util/Size;)V', + ); + + static final _putSize = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putSize(java.lang.String string, android.util.Size size) + void putSize( + jni.JString string, + jni.JObject size, + ) { + _putSize(reference.pointer, _id_putSize as jni.JMethodIDPtr, + string.reference.pointer, size.reference.pointer) + .check(); + } + + static final _id_putSizeF = _class.instanceMethodId( + r'putSizeF', + r'(Ljava/lang/String;Landroid/util/SizeF;)V', + ); + + static final _putSizeF = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putSizeF(java.lang.String string, android.util.SizeF sizeF) + void putSizeF( + jni.JString string, + jni.JObject sizeF, + ) { + _putSizeF(reference.pointer, _id_putSizeF as jni.JMethodIDPtr, + string.reference.pointer, sizeF.reference.pointer) + .check(); + } + + static final _id_putParcelableArray = _class.instanceMethodId( + r'putParcelableArray', + r'(Ljava/lang/String;[Landroid/os/Parcelable;)V', + ); + + static final _putParcelableArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putParcelableArray(java.lang.String string, android.os.Parcelable[] parcelables) + void putParcelableArray( + jni.JString string, + jni.JArray parcelables, + ) { + _putParcelableArray( + reference.pointer, + _id_putParcelableArray as jni.JMethodIDPtr, + string.reference.pointer, + parcelables.reference.pointer) + .check(); + } + + static final _id_putParcelableArrayList = _class.instanceMethodId( + r'putParcelableArrayList', + r'(Ljava/lang/String;Ljava/util/ArrayList;)V', + ); + + static final _putParcelableArrayList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putParcelableArrayList(java.lang.String string, java.util.ArrayList arrayList) + void putParcelableArrayList( + jni.JString string, + jni.JObject arrayList, + ) { + _putParcelableArrayList( + reference.pointer, + _id_putParcelableArrayList as jni.JMethodIDPtr, + string.reference.pointer, + arrayList.reference.pointer) + .check(); + } + + static final _id_putSparseParcelableArray = _class.instanceMethodId( + r'putSparseParcelableArray', + r'(Ljava/lang/String;Landroid/util/SparseArray;)V', + ); + + static final _putSparseParcelableArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putSparseParcelableArray(java.lang.String string, android.util.SparseArray sparseArray) + void putSparseParcelableArray( + jni.JString string, + jni.JObject sparseArray, + ) { + _putSparseParcelableArray( + reference.pointer, + _id_putSparseParcelableArray as jni.JMethodIDPtr, + string.reference.pointer, + sparseArray.reference.pointer) + .check(); + } + + static final _id_putIntegerArrayList = _class.instanceMethodId( + r'putIntegerArrayList', + r'(Ljava/lang/String;Ljava/util/ArrayList;)V', + ); + + static final _putIntegerArrayList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putIntegerArrayList(java.lang.String string, java.util.ArrayList arrayList) + void putIntegerArrayList( + jni.JString string, + jni.JObject arrayList, + ) { + _putIntegerArrayList( + reference.pointer, + _id_putIntegerArrayList as jni.JMethodIDPtr, + string.reference.pointer, + arrayList.reference.pointer) + .check(); + } + + static final _id_putStringArrayList = _class.instanceMethodId( + r'putStringArrayList', + r'(Ljava/lang/String;Ljava/util/ArrayList;)V', + ); + + static final _putStringArrayList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putStringArrayList(java.lang.String string, java.util.ArrayList arrayList) + void putStringArrayList( + jni.JString string, + jni.JObject arrayList, + ) { + _putStringArrayList( + reference.pointer, + _id_putStringArrayList as jni.JMethodIDPtr, + string.reference.pointer, + arrayList.reference.pointer) + .check(); + } + + static final _id_putCharSequenceArrayList = _class.instanceMethodId( + r'putCharSequenceArrayList', + r'(Ljava/lang/String;Ljava/util/ArrayList;)V', + ); + + static final _putCharSequenceArrayList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putCharSequenceArrayList(java.lang.String string, java.util.ArrayList arrayList) + void putCharSequenceArrayList( + jni.JString string, + jni.JObject arrayList, + ) { + _putCharSequenceArrayList( + reference.pointer, + _id_putCharSequenceArrayList as jni.JMethodIDPtr, + string.reference.pointer, + arrayList.reference.pointer) + .check(); + } + + static final _id_putSerializable = _class.instanceMethodId( + r'putSerializable', + r'(Ljava/lang/String;Ljava/io/Serializable;)V', + ); + + static final _putSerializable = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putSerializable(java.lang.String string, java.io.Serializable serializable) + void putSerializable( + jni.JString string, + jni.JObject serializable, + ) { + _putSerializable(reference.pointer, _id_putSerializable as jni.JMethodIDPtr, + string.reference.pointer, serializable.reference.pointer) + .check(); + } + + static final _id_putByteArray = _class.instanceMethodId( + r'putByteArray', + r'(Ljava/lang/String;[B)V', + ); + + static final _putByteArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putByteArray(java.lang.String string, byte[] bs) + void putByteArray( + jni.JString string, + jni.JArray bs, + ) { + _putByteArray(reference.pointer, _id_putByteArray as jni.JMethodIDPtr, + string.reference.pointer, bs.reference.pointer) + .check(); + } + + static final _id_putShortArray = _class.instanceMethodId( + r'putShortArray', + r'(Ljava/lang/String;[S)V', + ); + + static final _putShortArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putShortArray(java.lang.String string, short[] ss) + void putShortArray( + jni.JString string, + jni.JArray ss, + ) { + _putShortArray(reference.pointer, _id_putShortArray as jni.JMethodIDPtr, + string.reference.pointer, ss.reference.pointer) + .check(); + } + + static final _id_putCharArray = _class.instanceMethodId( + r'putCharArray', + r'(Ljava/lang/String;[C)V', + ); + + static final _putCharArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putCharArray(java.lang.String string, char[] cs) + void putCharArray( + jni.JString string, + jni.JArray cs, + ) { + _putCharArray(reference.pointer, _id_putCharArray as jni.JMethodIDPtr, + string.reference.pointer, cs.reference.pointer) + .check(); + } + + static final _id_putFloatArray = _class.instanceMethodId( + r'putFloatArray', + r'(Ljava/lang/String;[F)V', + ); + + static final _putFloatArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putFloatArray(java.lang.String string, float[] fs) + void putFloatArray( + jni.JString string, + jni.JArray fs, + ) { + _putFloatArray(reference.pointer, _id_putFloatArray as jni.JMethodIDPtr, + string.reference.pointer, fs.reference.pointer) + .check(); + } + + static final _id_putCharSequenceArray = _class.instanceMethodId( + r'putCharSequenceArray', + r'(Ljava/lang/String;[Ljava/lang/CharSequence;)V', + ); + + static final _putCharSequenceArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putCharSequenceArray(java.lang.String string, java.lang.CharSequence[] charSequences) + void putCharSequenceArray( + jni.JString string, + jni.JArray charSequences, + ) { + _putCharSequenceArray( + reference.pointer, + _id_putCharSequenceArray as jni.JMethodIDPtr, + string.reference.pointer, + charSequences.reference.pointer) + .check(); + } + + static final _id_putBundle = _class.instanceMethodId( + r'putBundle', + r'(Ljava/lang/String;Landroid/os/Bundle;)V', + ); + + static final _putBundle = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putBundle(java.lang.String string, android.os.Bundle bundle) + void putBundle( + jni.JString string, + Bundle bundle, + ) { + _putBundle(reference.pointer, _id_putBundle as jni.JMethodIDPtr, + string.reference.pointer, bundle.reference.pointer) + .check(); + } + + static final _id_putBinder = _class.instanceMethodId( + r'putBinder', + r'(Ljava/lang/String;Landroid/os/IBinder;)V', + ); + + static final _putBinder = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public void putBinder(java.lang.String string, android.os.IBinder iBinder) + void putBinder( + jni.JString string, + jni.JObject iBinder, + ) { + _putBinder(reference.pointer, _id_putBinder as jni.JMethodIDPtr, + string.reference.pointer, iBinder.reference.pointer) + .check(); + } + + static final _id_getByte = _class.instanceMethodId( + r'getByte', + r'(Ljava/lang/String;)B', + ); + + static final _getByte = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallByteMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public byte getByte(java.lang.String string) + int getByte( + jni.JString string, + ) { + return _getByte(reference.pointer, _id_getByte as jni.JMethodIDPtr, + string.reference.pointer) + .byte; + } + + static final _id_getByte1 = _class.instanceMethodId( + r'getByte', + r'(Ljava/lang/String;B)Ljava/lang/Byte;', + ); + + static final _getByte1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public java.lang.Byte getByte(java.lang.String string, byte b) + /// The returned object must be released after use, by calling the [release] method. + jni.JByte getByte1( + jni.JString string, + int b, + ) { + return _getByte1(reference.pointer, _id_getByte1 as jni.JMethodIDPtr, + string.reference.pointer, b) + .object(const jni.JByteType()); + } + + static final _id_getChar = _class.instanceMethodId( + r'getChar', + r'(Ljava/lang/String;)C', + ); + + static final _getChar = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallCharMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public char getChar(java.lang.String string) + int getChar( + jni.JString string, + ) { + return _getChar(reference.pointer, _id_getChar as jni.JMethodIDPtr, + string.reference.pointer) + .char; + } + + static final _id_getChar1 = _class.instanceMethodId( + r'getChar', + r'(Ljava/lang/String;C)C', + ); + + static final _getChar1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallCharMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public char getChar(java.lang.String string, char c) + int getChar1( + jni.JString string, + int c, + ) { + return _getChar1(reference.pointer, _id_getChar1 as jni.JMethodIDPtr, + string.reference.pointer, c) + .char; + } + + static final _id_getShort = _class.instanceMethodId( + r'getShort', + r'(Ljava/lang/String;)S', + ); + + static final _getShort = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallShortMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public short getShort(java.lang.String string) + int getShort( + jni.JString string, + ) { + return _getShort(reference.pointer, _id_getShort as jni.JMethodIDPtr, + string.reference.pointer) + .short; + } + + static final _id_getShort1 = _class.instanceMethodId( + r'getShort', + r'(Ljava/lang/String;S)S', + ); + + static final _getShort1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallShortMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public short getShort(java.lang.String string, short s) + int getShort1( + jni.JString string, + int s, + ) { + return _getShort1(reference.pointer, _id_getShort1 as jni.JMethodIDPtr, + string.reference.pointer, s) + .short; + } + + static final _id_getFloat = _class.instanceMethodId( + r'getFloat', + r'(Ljava/lang/String;)F', + ); + + static final _getFloat = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallFloatMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public float getFloat(java.lang.String string) + double getFloat( + jni.JString string, + ) { + return _getFloat(reference.pointer, _id_getFloat as jni.JMethodIDPtr, + string.reference.pointer) + .float; + } + + static final _id_getFloat1 = _class.instanceMethodId( + r'getFloat', + r'(Ljava/lang/String;F)F', + ); + + static final _getFloat1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, ffi.Double)>)>>( + 'globalEnv_CallFloatMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, double)>(); + + /// from: public float getFloat(java.lang.String string, float f) + double getFloat1( + jni.JString string, + double f, + ) { + return _getFloat1(reference.pointer, _id_getFloat1 as jni.JMethodIDPtr, + string.reference.pointer, f) + .float; + } + + static final _id_getCharSequence = _class.instanceMethodId( + r'getCharSequence', + r'(Ljava/lang/String;)Ljava/lang/CharSequence;', + ); + + static final _getCharSequence = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.lang.CharSequence getCharSequence(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getCharSequence( + jni.JString string, + ) { + return _getCharSequence(reference.pointer, + _id_getCharSequence as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getCharSequence1 = _class.instanceMethodId( + r'getCharSequence', + r'(Ljava/lang/String;Ljava/lang/CharSequence;)Ljava/lang/CharSequence;', + ); + + static final _getCharSequence1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public java.lang.CharSequence getCharSequence(java.lang.String string, java.lang.CharSequence charSequence) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getCharSequence1( + jni.JString string, + jni.JObject charSequence, + ) { + return _getCharSequence1( + reference.pointer, + _id_getCharSequence1 as jni.JMethodIDPtr, + string.reference.pointer, + charSequence.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getSize = _class.instanceMethodId( + r'getSize', + r'(Ljava/lang/String;)Landroid/util/Size;', + ); + + static final _getSize = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.util.Size getSize(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSize( + jni.JString string, + ) { + return _getSize(reference.pointer, _id_getSize as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getSizeF = _class.instanceMethodId( + r'getSizeF', + r'(Ljava/lang/String;)Landroid/util/SizeF;', + ); + + static final _getSizeF = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.util.SizeF getSizeF(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSizeF( + jni.JString string, + ) { + return _getSizeF(reference.pointer, _id_getSizeF as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getBundle = _class.instanceMethodId( + r'getBundle', + r'(Ljava/lang/String;)Landroid/os/Bundle;', + ); + + static final _getBundle = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.os.Bundle getBundle(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + Bundle getBundle( + jni.JString string, + ) { + return _getBundle(reference.pointer, _id_getBundle as jni.JMethodIDPtr, + string.reference.pointer) + .object(const $BundleType()); + } + + static final _id_getParcelable = _class.instanceMethodId( + r'getParcelable', + r'(Ljava/lang/String;)Landroid/os/Parcelable;', + ); + + static final _getParcelable = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public T getParcelable(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + $T getParcelable<$T extends jni.JObject>( + jni.JString string, { + required jni.JObjType<$T> T, + }) { + return _getParcelable(reference.pointer, + _id_getParcelable as jni.JMethodIDPtr, string.reference.pointer) + .object(T); + } + + static final _id_getParcelable1 = _class.instanceMethodId( + r'getParcelable', + r'(Ljava/lang/String;Ljava/lang/Class;)Ljava/lang/Object;', + ); + + static final _getParcelable1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public T getParcelable(java.lang.String string, java.lang.Class class) + /// The returned object must be released after use, by calling the [release] method. + $T getParcelable1<$T extends jni.JObject>( + jni.JString string, + jni.JObject class0, { + required jni.JObjType<$T> T, + }) { + return _getParcelable1( + reference.pointer, + _id_getParcelable1 as jni.JMethodIDPtr, + string.reference.pointer, + class0.reference.pointer) + .object(T); + } + + static final _id_getParcelableArray = _class.instanceMethodId( + r'getParcelableArray', + r'(Ljava/lang/String;)[Landroid/os/Parcelable;', + ); + + static final _getParcelableArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.os.Parcelable[] getParcelableArray(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getParcelableArray( + jni.JString string, + ) { + return _getParcelableArray( + reference.pointer, + _id_getParcelableArray as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JArrayType(jni.JObjectType())); + } + + static final _id_getParcelableArray1 = _class.instanceMethodId( + r'getParcelableArray', + r'(Ljava/lang/String;Ljava/lang/Class;)[Ljava/lang/Object;', + ); + + static final _getParcelableArray1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public java.lang.Object[] getParcelableArray(java.lang.String string, java.lang.Class class) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray<$T> getParcelableArray1<$T extends jni.JObject>( + jni.JString string, + jni.JObject class0, { + required jni.JObjType<$T> T, + }) { + return _getParcelableArray1( + reference.pointer, + _id_getParcelableArray1 as jni.JMethodIDPtr, + string.reference.pointer, + class0.reference.pointer) + .object(jni.JArrayType(T)); + } + + static final _id_getParcelableArrayList = _class.instanceMethodId( + r'getParcelableArrayList', + r'(Ljava/lang/String;)Ljava/util/ArrayList;', + ); + + static final _getParcelableArrayList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.util.ArrayList getParcelableArrayList(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getParcelableArrayList<$T extends jni.JObject>( + jni.JString string, { + required jni.JObjType<$T> T, + }) { + return _getParcelableArrayList( + reference.pointer, + _id_getParcelableArrayList as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getParcelableArrayList1 = _class.instanceMethodId( + r'getParcelableArrayList', + r'(Ljava/lang/String;Ljava/lang/Class;)Ljava/util/ArrayList;', + ); + + static final _getParcelableArrayList1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public java.util.ArrayList getParcelableArrayList(java.lang.String string, java.lang.Class class) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getParcelableArrayList1<$T extends jni.JObject>( + jni.JString string, + jni.JObject class0, { + required jni.JObjType<$T> T, + }) { + return _getParcelableArrayList1( + reference.pointer, + _id_getParcelableArrayList1 as jni.JMethodIDPtr, + string.reference.pointer, + class0.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getSparseParcelableArray = _class.instanceMethodId( + r'getSparseParcelableArray', + r'(Ljava/lang/String;)Landroid/util/SparseArray;', + ); + + static final _getSparseParcelableArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.util.SparseArray getSparseParcelableArray(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSparseParcelableArray<$T extends jni.JObject>( + jni.JString string, { + required jni.JObjType<$T> T, + }) { + return _getSparseParcelableArray( + reference.pointer, + _id_getSparseParcelableArray as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getSparseParcelableArray1 = _class.instanceMethodId( + r'getSparseParcelableArray', + r'(Ljava/lang/String;Ljava/lang/Class;)Landroid/util/SparseArray;', + ); + + static final _getSparseParcelableArray1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public android.util.SparseArray getSparseParcelableArray(java.lang.String string, java.lang.Class class) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSparseParcelableArray1<$T extends jni.JObject>( + jni.JString string, + jni.JObject class0, { + required jni.JObjType<$T> T, + }) { + return _getSparseParcelableArray1( + reference.pointer, + _id_getSparseParcelableArray1 as jni.JMethodIDPtr, + string.reference.pointer, + class0.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getSerializable = _class.instanceMethodId( + r'getSerializable', + r'(Ljava/lang/String;)Ljava/io/Serializable;', + ); + + static final _getSerializable = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.io.Serializable getSerializable(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getSerializable( + jni.JString string, + ) { + return _getSerializable(reference.pointer, + _id_getSerializable as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getSerializable1 = _class.instanceMethodId( + r'getSerializable', + r'(Ljava/lang/String;Ljava/lang/Class;)Ljava/io/Serializable;', + ); + + static final _getSerializable1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs< + ( + ffi.Pointer, + ffi.Pointer + )>)>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, ffi.Pointer)>(); + + /// from: public T getSerializable(java.lang.String string, java.lang.Class class) + /// The returned object must be released after use, by calling the [release] method. + $T getSerializable1<$T extends jni.JObject>( + jni.JString string, + jni.JObject class0, { + required jni.JObjType<$T> T, + }) { + return _getSerializable1( + reference.pointer, + _id_getSerializable1 as jni.JMethodIDPtr, + string.reference.pointer, + class0.reference.pointer) + .object(T); + } + + static final _id_getIntegerArrayList = _class.instanceMethodId( + r'getIntegerArrayList', + r'(Ljava/lang/String;)Ljava/util/ArrayList;', + ); + + static final _getIntegerArrayList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.util.ArrayList getIntegerArrayList(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getIntegerArrayList( + jni.JString string, + ) { + return _getIntegerArrayList( + reference.pointer, + _id_getIntegerArrayList as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getStringArrayList = _class.instanceMethodId( + r'getStringArrayList', + r'(Ljava/lang/String;)Ljava/util/ArrayList;', + ); + + static final _getStringArrayList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.util.ArrayList getStringArrayList(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getStringArrayList( + jni.JString string, + ) { + return _getStringArrayList( + reference.pointer, + _id_getStringArrayList as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getCharSequenceArrayList = _class.instanceMethodId( + r'getCharSequenceArrayList', + r'(Ljava/lang/String;)Ljava/util/ArrayList;', + ); + + static final _getCharSequenceArrayList = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.util.ArrayList getCharSequenceArrayList(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getCharSequenceArrayList( + jni.JString string, + ) { + return _getCharSequenceArrayList( + reference.pointer, + _id_getCharSequenceArrayList as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_getByteArray = _class.instanceMethodId( + r'getByteArray', + r'(Ljava/lang/String;)[B', + ); + + static final _getByteArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public byte[] getByteArray(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getByteArray( + jni.JString string, + ) { + return _getByteArray(reference.pointer, + _id_getByteArray as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JArrayType(jni.jbyteType())); + } + + static final _id_getShortArray = _class.instanceMethodId( + r'getShortArray', + r'(Ljava/lang/String;)[S', + ); + + static final _getShortArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public short[] getShortArray(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getShortArray( + jni.JString string, + ) { + return _getShortArray(reference.pointer, + _id_getShortArray as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JArrayType(jni.jshortType())); + } + + static final _id_getCharArray = _class.instanceMethodId( + r'getCharArray', + r'(Ljava/lang/String;)[C', + ); + + static final _getCharArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public char[] getCharArray(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getCharArray( + jni.JString string, + ) { + return _getCharArray(reference.pointer, + _id_getCharArray as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JArrayType(jni.jcharType())); + } + + static final _id_getFloatArray = _class.instanceMethodId( + r'getFloatArray', + r'(Ljava/lang/String;)[F', + ); + + static final _getFloatArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public float[] getFloatArray(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getFloatArray( + jni.JString string, + ) { + return _getFloatArray(reference.pointer, + _id_getFloatArray as jni.JMethodIDPtr, string.reference.pointer) + .object(const jni.JArrayType(jni.jfloatType())); + } + + static final _id_getCharSequenceArray = _class.instanceMethodId( + r'getCharSequenceArray', + r'(Ljava/lang/String;)[Ljava/lang/CharSequence;', + ); + + static final _getCharSequenceArray = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public java.lang.CharSequence[] getCharSequenceArray(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JArray getCharSequenceArray( + jni.JString string, + ) { + return _getCharSequenceArray( + reference.pointer, + _id_getCharSequenceArray as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JArrayType(jni.JObjectType())); + } + + static final _id_getBinder = _class.instanceMethodId( + r'getBinder', + r'(Ljava/lang/String;)Landroid/os/IBinder;', + ); + + static final _getBinder = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public android.os.IBinder getBinder(java.lang.String string) + /// The returned object must be released after use, by calling the [release] method. + jni.JObject getBinder( + jni.JString string, + ) { + return _getBinder(reference.pointer, _id_getBinder as jni.JMethodIDPtr, + string.reference.pointer) + .object(const jni.JObjectType()); + } + + static final _id_describeContents = _class.instanceMethodId( + r'describeContents', + r'()I', + ); + + static final _describeContents = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallIntMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public int describeContents() + int describeContents() { + return _describeContents( + reference.pointer, _id_describeContents as jni.JMethodIDPtr) + .integer; + } + + static final _id_writeToParcel = _class.instanceMethodId( + r'writeToParcel', + r'(Landroid/os/Parcel;I)V', + ); + + static final _writeToParcel = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer, $Int32)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer, int)>(); + + /// from: public void writeToParcel(android.os.Parcel parcel, int i) + void writeToParcel( + jni.JObject parcel, + int i, + ) { + _writeToParcel(reference.pointer, _id_writeToParcel as jni.JMethodIDPtr, + parcel.reference.pointer, i) + .check(); + } + + static final _id_readFromParcel = _class.instanceMethodId( + r'readFromParcel', + r'(Landroid/os/Parcel;)V', + ); + + static final _readFromParcel = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void readFromParcel(android.os.Parcel parcel) + void readFromParcel( + jni.JObject parcel, + ) { + _readFromParcel(reference.pointer, _id_readFromParcel as jni.JMethodIDPtr, + parcel.reference.pointer) + .check(); + } + + static final _id_toString1 = _class.instanceMethodId( + r'toString', + r'()Ljava/lang/String;', + ); + + static final _toString1 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallObjectMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public java.lang.String toString() + /// The returned object must be released after use, by calling the [release] method. + jni.JString toString1() { + return _toString1(reference.pointer, _id_toString1 as jni.JMethodIDPtr) + .object(const jni.JStringType()); + } +} + +final class $BundleType extends jni.JObjType { + const $BundleType(); + + @override + String get signature => r'Landroid/os/Bundle;'; + + @override + Bundle fromReference(jni.JReference reference) => + Bundle.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($BundleType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($BundleType) && other is $BundleType; + } +} + +/// from: android.os.CancellationSignal$OnCancelListener +class CancellationSignal_OnCancelListener extends jni.JObject { + @override + late final jni.JObjType $type = type; + + CancellationSignal_OnCancelListener.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = + jni.JClass.forName(r'android/os/CancellationSignal$OnCancelListener'); + + /// The type which includes information such as the signature of this class. + static const type = $CancellationSignal_OnCancelListenerType(); + static final _id_onCancel = _class.instanceMethodId( + r'onCancel', + r'()V', + ); + + static final _onCancel = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public abstract void onCancel() + void onCancel() { + _onCancel(reference.pointer, _id_onCancel as jni.JMethodIDPtr).check(); + } + + /// Maps a specific port to the implemented interface. + static final Map _$impls = {}; + ReceivePort? _$p; + + static jni.JObjectPtr _$invoke( + int port, + jni.JObjectPtr descriptor, + jni.JObjectPtr args, + ) { + return _$invokeMethod( + port, + $MethodInvocation.fromAddresses( + 0, + descriptor.address, + args.address, + ), + ); + } + + static final ffi.Pointer< + ffi.NativeFunction< + jni.JObjectPtr Function( + ffi.Uint64, jni.JObjectPtr, jni.JObjectPtr)>> + _$invokePointer = ffi.Pointer.fromFunction(_$invoke); + + static ffi.Pointer _$invokeMethod( + int $p, + $MethodInvocation $i, + ) { + try { + final $d = $i.methodDescriptor.toDartString(releaseOriginal: true); + final $a = $i.args; + if ($d == r'onCancel()V') { + _$impls[$p]!.onCancel(); + return jni.nullptr; + } + } catch (e) { + return ProtectedJniExtensions.newDartException(e); + } + return jni.nullptr; + } + + factory CancellationSignal_OnCancelListener.implement( + $CancellationSignal_OnCancelListenerImpl $impl, + ) { + final $p = ReceivePort(); + final $x = CancellationSignal_OnCancelListener.fromReference( + ProtectedJniExtensions.newPortProxy( + r'android.os.CancellationSignal$OnCancelListener', + $p, + _$invokePointer, + ), + ).._$p = $p; + final $a = $p.sendPort.nativePort; + _$impls[$a] = $impl; + $p.listen(($m) { + if ($m == null) { + _$impls.remove($p.sendPort.nativePort); + $p.close(); + return; + } + final $i = $MethodInvocation.fromMessage($m as List); + final $r = _$invokeMethod($p.sendPort.nativePort, $i); + ProtectedJniExtensions.returnResult($i.result, $r); + }); + return $x; + } +} + +abstract interface class $CancellationSignal_OnCancelListenerImpl { + factory $CancellationSignal_OnCancelListenerImpl({ + required void Function() onCancel, + }) = _$CancellationSignal_OnCancelListenerImpl; + + void onCancel(); +} + +class _$CancellationSignal_OnCancelListenerImpl + implements $CancellationSignal_OnCancelListenerImpl { + _$CancellationSignal_OnCancelListenerImpl({ + required void Function() onCancel, + }) : _onCancel = onCancel; + + final void Function() _onCancel; + + void onCancel() { + return _onCancel(); + } +} + +final class $CancellationSignal_OnCancelListenerType + extends jni.JObjType { + const $CancellationSignal_OnCancelListenerType(); + + @override + String get signature => r'Landroid/os/CancellationSignal$OnCancelListener;'; + + @override + CancellationSignal_OnCancelListener fromReference(jni.JReference reference) => + CancellationSignal_OnCancelListener.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($CancellationSignal_OnCancelListenerType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($CancellationSignal_OnCancelListenerType) && + other is $CancellationSignal_OnCancelListenerType; + } +} + +/// from: android.os.CancellationSignal +class CancellationSignal extends jni.JObject { + @override + late final jni.JObjType $type = type; + + CancellationSignal.fromReference( + jni.JReference reference, + ) : super.fromReference(reference); + + static final _class = jni.JClass.forName(r'android/os/CancellationSignal'); + + /// The type which includes information such as the signature of this class. + static const type = $CancellationSignalType(); + static final _id_new0 = _class.constructorId( + r'()V', + ); + + static final _new0 = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_NewObject') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void () + /// The returned object must be released after use, by calling the [release] method. + factory CancellationSignal() { + return CancellationSignal.fromReference( + _new0(_class.reference.pointer, _id_new0 as jni.JMethodIDPtr) + .reference); + } + + static final _id_isCanceled = _class.instanceMethodId( + r'isCanceled', + r'()Z', + ); + + static final _isCanceled = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallBooleanMethod') + .asFunction< + jni.JniResult Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public boolean isCanceled() + bool isCanceled() { + return _isCanceled(reference.pointer, _id_isCanceled as jni.JMethodIDPtr) + .boolean; + } + + static final _id_throwIfCanceled = _class.instanceMethodId( + r'throwIfCanceled', + r'()V', + ); + + static final _throwIfCanceled = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void throwIfCanceled() + void throwIfCanceled() { + _throwIfCanceled(reference.pointer, _id_throwIfCanceled as jni.JMethodIDPtr) + .check(); + } + + static final _id_cancel = _class.instanceMethodId( + r'cancel', + r'()V', + ); + + static final _cancel = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>>('globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + )>(); + + /// from: public void cancel() + void cancel() { + _cancel(reference.pointer, _id_cancel as jni.JMethodIDPtr).check(); + } + + static final _id_setOnCancelListener = _class.instanceMethodId( + r'setOnCancelListener', + r'(Landroid/os/CancellationSignal$OnCancelListener;)V', + ); + + static final _setOnCancelListener = ProtectedJniExtensions.lookup< + ffi.NativeFunction< + jni.JThrowablePtr Function( + ffi.Pointer, + jni.JMethodIDPtr, + ffi.VarArgs<(ffi.Pointer,)>)>>( + 'globalEnv_CallVoidMethod') + .asFunction< + jni.JThrowablePtr Function(ffi.Pointer, jni.JMethodIDPtr, + ffi.Pointer)>(); + + /// from: public void setOnCancelListener(android.os.CancellationSignal$OnCancelListener onCancelListener) + void setOnCancelListener( + CancellationSignal_OnCancelListener onCancelListener, + ) { + _setOnCancelListener( + reference.pointer, + _id_setOnCancelListener as jni.JMethodIDPtr, + onCancelListener.reference.pointer) + .check(); + } +} + +final class $CancellationSignalType extends jni.JObjType { + const $CancellationSignalType(); + + @override + String get signature => r'Landroid/os/CancellationSignal;'; + + @override + CancellationSignal fromReference(jni.JReference reference) => + CancellationSignal.fromReference(reference); + + @override + jni.JObjType get superType => const jni.JObjectType(); + + @override + final superCount = 1; + + @override + int get hashCode => ($CancellationSignalType).hashCode; + + @override + bool operator ==(Object other) { + return other.runtimeType == ($CancellationSignalType) && + other is $CancellationSignalType; + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/native/ios/authentication_services.ffi.dart b/packages/native/auth/native_auth_flutter/lib/src/native/ios/authentication_services.ffi.dart new file mode 100644 index 0000000..2d2bd15 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/native/ios/authentication_services.ffi.dart @@ -0,0 +1,31979 @@ +// ignore_for_file: type=lint +// ignore_for_file: return_of_invalid_type + +// AUTO GENERATED FILE, DO NOT EDIT. +// +// Generated by `package:ffigen`. +import 'dart:ffi' as ffi; +import 'package:objective_c/objective_c.dart' as objc; + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSTimer( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_UIImage( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_objcObjCObject( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSError( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_UIAction( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSDate_bool_bool( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSError1( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSURL_NSError( + ffi.Pointer block, +); + +/// UIApplication +class UIApplication extends UIResponder { + UIApplication._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIApplication] that points to the same underlying object as [other]. + UIApplication.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIApplication] that wraps the given raw object pointer. + UIApplication.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIApplication]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIApplication); + } + + /// sharedApplication + static UIApplication getSharedApplication() { + final _ret = _objc_msgSend_1(_class_UIApplication, _sel_sharedApplication); + return UIApplication.castFromPointer(_ret, retain: true, release: true); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// beginIgnoringInteractionEvents + void beginIgnoringInteractionEvents() { + _objc_msgSend_4(this.pointer, _sel_beginIgnoringInteractionEvents); + } + + /// endIgnoringInteractionEvents + void endIgnoringInteractionEvents() { + _objc_msgSend_4(this.pointer, _sel_endIgnoringInteractionEvents); + } + + /// isIgnoringInteractionEvents + bool get ignoringInteractionEvents { + return _objc_msgSend_5(this.pointer, _sel_isIgnoringInteractionEvents); + } + + /// isIdleTimerDisabled + bool get idleTimerDisabled { + return _objc_msgSend_5(this.pointer, _sel_isIdleTimerDisabled); + } + + /// setIdleTimerDisabled: + set idleTimerDisabled(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setIdleTimerDisabled_, value); + } + + /// openURL: + bool openURL_(objc.NSURL url) { + return _objc_msgSend_7(this.pointer, _sel_openURL_, url.pointer); + } + + /// canOpenURL: + bool canOpenURL_(objc.NSURL url) { + return _objc_msgSend_7(this.pointer, _sel_canOpenURL_, url.pointer); + } + + /// openURL:options:completionHandler: + void openURL_options_completionHandler_(objc.NSURL url, + objc.NSDictionary options, ObjCBlock_ffiVoid_bool? completion) { + _objc_msgSend_8(this.pointer, _sel_openURL_options_completionHandler_, + url.pointer, options.pointer, completion?.pointer ?? ffi.nullptr); + } + + /// sendEvent: + void sendEvent_(UIEvent event) { + _objc_msgSend_564(this.pointer, _sel_sendEvent_, event.pointer); + } + + /// keyWindow + UIWindow? get keyWindow { + final _ret = _objc_msgSend_381(this.pointer, _sel_keyWindow); + return _ret.address == 0 + ? null + : UIWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// windows + objc.NSArray get windows { + final _ret = _objc_msgSend_14(this.pointer, _sel_windows); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// sendAction:to:from:forEvent: + bool sendAction_to_from_forEvent_( + ffi.Pointer action, + objc.ObjCObjectBase? target, + objc.ObjCObjectBase? sender, + UIEvent? event) { + return _objc_msgSend_571( + this.pointer, + _sel_sendAction_to_from_forEvent_, + action, + target?.pointer ?? ffi.nullptr, + sender?.pointer ?? ffi.nullptr, + event?.pointer ?? ffi.nullptr); + } + + /// isNetworkActivityIndicatorVisible + bool get networkActivityIndicatorVisible { + return _objc_msgSend_5( + this.pointer, _sel_isNetworkActivityIndicatorVisible); + } + + /// setNetworkActivityIndicatorVisible: + set networkActivityIndicatorVisible(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setNetworkActivityIndicatorVisible_, value); + } + + /// statusBarStyle + UIStatusBarStyle get statusBarStyle { + final _ret = _objc_msgSend_503(this.pointer, _sel_statusBarStyle); + return UIStatusBarStyle.fromValue(_ret); + } + + /// isStatusBarHidden + bool get statusBarHidden { + return _objc_msgSend_5(this.pointer, _sel_isStatusBarHidden); + } + + /// statusBarOrientation + UIInterfaceOrientation get statusBarOrientation { + final _ret = _objc_msgSend_376(this.pointer, _sel_statusBarOrientation); + return UIInterfaceOrientation.fromValue(_ret); + } + + /// supportedInterfaceOrientationsForWindow: + UIInterfaceOrientationMask supportedInterfaceOrientationsForWindow_( + UIWindow? window) { + final _ret = _objc_msgSend_572( + this.pointer, + _sel_supportedInterfaceOrientationsForWindow_, + window?.pointer ?? ffi.nullptr); + return UIInterfaceOrientationMask.fromValue(_ret); + } + + /// statusBarOrientationAnimationDuration + double get statusBarOrientationAnimationDuration { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret( + this.pointer, _sel_statusBarOrientationAnimationDuration) + : _objc_msgSend_11( + this.pointer, _sel_statusBarOrientationAnimationDuration); + } + + /// statusBarFrame + void getStatusBarFrame(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_statusBarFrame) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_statusBarFrame); + } + + /// applicationIconBadgeNumber + int get applicationIconBadgeNumber { + return _objc_msgSend_48(this.pointer, _sel_applicationIconBadgeNumber); + } + + /// setApplicationIconBadgeNumber: + set applicationIconBadgeNumber(int value) { + return _objc_msgSend_49( + this.pointer, _sel_setApplicationIconBadgeNumber_, value); + } + + /// applicationSupportsShakeToEdit + bool get applicationSupportsShakeToEdit { + return _objc_msgSend_5(this.pointer, _sel_applicationSupportsShakeToEdit); + } + + /// setApplicationSupportsShakeToEdit: + set applicationSupportsShakeToEdit(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setApplicationSupportsShakeToEdit_, value); + } + + /// applicationState + UIApplicationState get applicationState { + final _ret = _objc_msgSend_573(this.pointer, _sel_applicationState); + return UIApplicationState.fromValue(_ret); + } + + /// backgroundTimeRemaining + double get backgroundTimeRemaining { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_backgroundTimeRemaining) + : _objc_msgSend_11(this.pointer, _sel_backgroundTimeRemaining); + } + + /// beginBackgroundTaskWithExpirationHandler: + int beginBackgroundTaskWithExpirationHandler_(ObjCBlock_ffiVoid? handler) { + return _objc_msgSend_574( + this.pointer, + _sel_beginBackgroundTaskWithExpirationHandler_, + handler?.pointer ?? ffi.nullptr); + } + + /// beginBackgroundTaskWithName:expirationHandler: + int beginBackgroundTaskWithName_expirationHandler_( + objc.NSString? taskName, ObjCBlock_ffiVoid? handler) { + return _objc_msgSend_575( + this.pointer, + _sel_beginBackgroundTaskWithName_expirationHandler_, + taskName?.pointer ?? ffi.nullptr, + handler?.pointer ?? ffi.nullptr); + } + + /// endBackgroundTask: + void endBackgroundTask_(int identifier) { + _objc_msgSend_576(this.pointer, _sel_endBackgroundTask_, identifier); + } + + /// setMinimumBackgroundFetchInterval: + void setMinimumBackgroundFetchInterval_( + double minimumBackgroundFetchInterval) { + _objc_msgSend_577(this.pointer, _sel_setMinimumBackgroundFetchInterval_, + minimumBackgroundFetchInterval); + } + + /// backgroundRefreshStatus + UIBackgroundRefreshStatus get backgroundRefreshStatus { + final _ret = _objc_msgSend_578(this.pointer, _sel_backgroundRefreshStatus); + return UIBackgroundRefreshStatus.fromValue(_ret); + } + + /// isProtectedDataAvailable + bool get protectedDataAvailable { + return _objc_msgSend_5(this.pointer, _sel_isProtectedDataAvailable); + } + + /// userInterfaceLayoutDirection + UIUserInterfaceLayoutDirection get userInterfaceLayoutDirection { + final _ret = + _objc_msgSend_113(this.pointer, _sel_userInterfaceLayoutDirection); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// preferredContentSizeCategory + objc.NSString get preferredContentSizeCategory { + final _ret = + _objc_msgSend_77(this.pointer, _sel_preferredContentSizeCategory); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// connectedScenes + objc.NSSet get connectedScenes { + final _ret = _objc_msgSend_118(this.pointer, _sel_connectedScenes); + return objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// openSessions + objc.NSSet get openSessions { + final _ret = _objc_msgSend_118(this.pointer, _sel_openSessions); + return objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// supportsMultipleScenes + bool get supportsMultipleScenes { + return _objc_msgSend_5(this.pointer, _sel_supportsMultipleScenes); + } + + /// activateSceneSessionForRequest:errorHandler: + void activateSceneSessionForRequest_errorHandler_( + UISceneSessionActivationRequest request, + ObjCBlock_ffiVoid_NSError? errorHandler) { + _objc_msgSend_586( + this.pointer, + _sel_activateSceneSessionForRequest_errorHandler_, + request.pointer, + errorHandler?.pointer ?? ffi.nullptr); + } + + /// requestSceneSessionActivation:userActivity:options:errorHandler: + void requestSceneSessionActivation_userActivity_options_errorHandler_( + UISceneSession? sceneSession, + NSUserActivity? userActivity, + UISceneActivationRequestOptions? options, + ObjCBlock_ffiVoid_NSError? errorHandler) { + _objc_msgSend_587( + this.pointer, + _sel_requestSceneSessionActivation_userActivity_options_errorHandler_, + sceneSession?.pointer ?? ffi.nullptr, + userActivity?.pointer ?? ffi.nullptr, + options?.pointer ?? ffi.nullptr, + errorHandler?.pointer ?? ffi.nullptr); + } + + /// requestSceneSessionDestruction:options:errorHandler: + void requestSceneSessionDestruction_options_errorHandler_( + UISceneSession sceneSession, + UISceneDestructionRequestOptions? options, + ObjCBlock_ffiVoid_NSError? errorHandler) { + _objc_msgSend_588( + this.pointer, + _sel_requestSceneSessionDestruction_options_errorHandler_, + sceneSession.pointer, + options?.pointer ?? ffi.nullptr, + errorHandler?.pointer ?? ffi.nullptr); + } + + /// requestSceneSessionRefresh: + void requestSceneSessionRefresh_(UISceneSession sceneSession) { + _objc_msgSend_589( + this.pointer, _sel_requestSceneSessionRefresh_, sceneSession.pointer); + } + + /// registerForRemoteNotifications + void registerForRemoteNotifications() { + _objc_msgSend_4(this.pointer, _sel_registerForRemoteNotifications); + } + + /// unregisterForRemoteNotifications + void unregisterForRemoteNotifications() { + _objc_msgSend_4(this.pointer, _sel_unregisterForRemoteNotifications); + } + + /// isRegisteredForRemoteNotifications + bool get registeredForRemoteNotifications { + return _objc_msgSend_5( + this.pointer, _sel_isRegisteredForRemoteNotifications); + } + + /// registerForRemoteNotificationTypes: + void registerForRemoteNotificationTypes_(UIRemoteNotificationType types) { + _objc_msgSend_590( + this.pointer, _sel_registerForRemoteNotificationTypes_, types.value); + } + + /// enabledRemoteNotificationTypes + UIRemoteNotificationType enabledRemoteNotificationTypes() { + final _ret = + _objc_msgSend_591(this.pointer, _sel_enabledRemoteNotificationTypes); + return UIRemoteNotificationType.fromValue(_ret); + } + + /// presentLocalNotificationNow: + void presentLocalNotificationNow_(UILocalNotification notification) { + _objc_msgSend_641( + this.pointer, _sel_presentLocalNotificationNow_, notification.pointer); + } + + /// scheduleLocalNotification: + void scheduleLocalNotification_(UILocalNotification notification) { + _objc_msgSend_641( + this.pointer, _sel_scheduleLocalNotification_, notification.pointer); + } + + /// cancelLocalNotification: + void cancelLocalNotification_(UILocalNotification notification) { + _objc_msgSend_641( + this.pointer, _sel_cancelLocalNotification_, notification.pointer); + } + + /// cancelAllLocalNotifications + void cancelAllLocalNotifications() { + _objc_msgSend_4(this.pointer, _sel_cancelAllLocalNotifications); + } + + /// scheduledLocalNotifications + objc.NSArray? get scheduledLocalNotifications { + final _ret = + _objc_msgSend_90(this.pointer, _sel_scheduledLocalNotifications); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// setScheduledLocalNotifications: + set scheduledLocalNotifications(objc.NSArray? value) { + return _objc_msgSend_91(this.pointer, _sel_setScheduledLocalNotifications_, + value?.pointer ?? ffi.nullptr); + } + + /// registerUserNotificationSettings: + void registerUserNotificationSettings_( + UIUserNotificationSettings notificationSettings) { + _objc_msgSend_644(this.pointer, _sel_registerUserNotificationSettings_, + notificationSettings.pointer); + } + + /// currentUserNotificationSettings + UIUserNotificationSettings? get currentUserNotificationSettings { + final _ret = + _objc_msgSend_645(this.pointer, _sel_currentUserNotificationSettings); + return _ret.address == 0 + ? null + : UIUserNotificationSettings.castFromPointer(_ret, + retain: true, release: true); + } + + /// beginReceivingRemoteControlEvents + void beginReceivingRemoteControlEvents() { + _objc_msgSend_4(this.pointer, _sel_beginReceivingRemoteControlEvents); + } + + /// endReceivingRemoteControlEvents + void endReceivingRemoteControlEvents() { + _objc_msgSend_4(this.pointer, _sel_endReceivingRemoteControlEvents); + } + + /// setNewsstandIconImage: + void setNewsstandIconImage_(UIImage? image) { + _objc_msgSend_646(this.pointer, _sel_setNewsstandIconImage_, + image?.pointer ?? ffi.nullptr); + } + + /// shortcutItems + objc.NSArray? get shortcutItems { + final _ret = _objc_msgSend_90(this.pointer, _sel_shortcutItems); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// setShortcutItems: + set shortcutItems(objc.NSArray? value) { + return _objc_msgSend_91( + this.pointer, _sel_setShortcutItems_, value?.pointer ?? ffi.nullptr); + } + + /// supportsAlternateIcons + bool get supportsAlternateIcons { + return _objc_msgSend_5(this.pointer, _sel_supportsAlternateIcons); + } + + /// setAlternateIconName:completionHandler: + void setAlternateIconName_completionHandler_(objc.NSString? alternateIconName, + ObjCBlock_ffiVoid_NSError1? completionHandler) { + _objc_msgSend_647( + this.pointer, + _sel_setAlternateIconName_completionHandler_, + alternateIconName?.pointer ?? ffi.nullptr, + completionHandler?.pointer ?? ffi.nullptr); + } + + /// alternateIconName + objc.NSString? get alternateIconName { + final _ret = _objc_msgSend_29(this.pointer, _sel_alternateIconName); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// extendStateRestoration + void extendStateRestoration() { + _objc_msgSend_4(this.pointer, _sel_extendStateRestoration); + } + + /// completeStateRestoration + void completeStateRestoration() { + _objc_msgSend_4(this.pointer, _sel_completeStateRestoration); + } + + /// ignoreSnapshotOnNextApplicationLaunch + void ignoreSnapshotOnNextApplicationLaunch() { + _objc_msgSend_4(this.pointer, _sel_ignoreSnapshotOnNextApplicationLaunch); + } + + /// registerObjectForStateRestoration:restorationIdentifier: + static void registerObjectForStateRestoration_restorationIdentifier_( + objc.ObjCObjectBase object, objc.NSString restorationIdentifier) { + _objc_msgSend_648( + _class_UIApplication, + _sel_registerObjectForStateRestoration_restorationIdentifier_, + object.pointer, + restorationIdentifier.pointer); + } + + /// isProximitySensingEnabled + bool get proximitySensingEnabled { + return _objc_msgSend_5(this.pointer, _sel_isProximitySensingEnabled); + } + + /// setProximitySensingEnabled: + set proximitySensingEnabled(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setProximitySensingEnabled_, value); + } + + /// setStatusBarHidden:animated: + void setStatusBarHidden_animated_(bool hidden, bool animated) { + _objc_msgSend_649( + this.pointer, _sel_setStatusBarHidden_animated_, hidden, animated); + } + + /// setStatusBarOrientation: + set statusBarOrientation(UIInterfaceOrientation value) { + return _objc_msgSend_650( + this.pointer, _sel_setStatusBarOrientation_, value.value); + } + + /// setStatusBarOrientation:animated: + void setStatusBarOrientation_animated_( + UIInterfaceOrientation interfaceOrientation, bool animated) { + _objc_msgSend_651(this.pointer, _sel_setStatusBarOrientation_animated_, + interfaceOrientation.value, animated); + } + + /// setStatusBarStyle: + set statusBarStyle(UIStatusBarStyle value) { + return _objc_msgSend_652( + this.pointer, _sel_setStatusBarStyle_, value.value); + } + + /// setStatusBarStyle:animated: + void setStatusBarStyle_animated_( + UIStatusBarStyle statusBarStyle, bool animated) { + _objc_msgSend_653(this.pointer, _sel_setStatusBarStyle_animated_, + statusBarStyle.value, animated); + } + + /// setStatusBarHidden: + set statusBarHidden(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setStatusBarHidden_, value); + } + + /// setStatusBarHidden:withAnimation: + void setStatusBarHidden_withAnimation_( + bool hidden, UIStatusBarAnimation animation) { + _objc_msgSend_654(this.pointer, _sel_setStatusBarHidden_withAnimation_, + hidden, animation.value); + } + + /// setKeepAliveTimeout:handler: + bool setKeepAliveTimeout_handler_( + double timeout, ObjCBlock_ffiVoid? keepAliveHandler) { + return _objc_msgSend_655(this.pointer, _sel_setKeepAliveTimeout_handler_, + timeout, keepAliveHandler?.pointer ?? ffi.nullptr); + } + + /// clearKeepAliveTimeout + void clearKeepAliveTimeout() { + _objc_msgSend_4(this.pointer, _sel_clearKeepAliveTimeout); + } + + /// init + UIApplication init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIApplication.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIApplication new1() { + final _ret = _objc_msgSend_18(_class_UIApplication, _sel_new); + return UIApplication.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIApplication allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIApplication, _sel_allocWithZone_, zone); + return UIApplication.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIApplication alloc() { + final _ret = _objc_msgSend_18(_class_UIApplication, _sel_alloc); + return UIApplication.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIApplication = objc.getClass("UIApplication"); +late final _sel_sharedApplication = objc.registerName("sharedApplication"); +final _objc_msgSend_1 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_delegate = objc.registerName("delegate"); +final _objc_msgSend_2 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setDelegate_ = objc.registerName("setDelegate:"); +final _objc_msgSend_3 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_beginIgnoringInteractionEvents = + objc.registerName("beginIgnoringInteractionEvents"); +final _objc_msgSend_4 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_endIgnoringInteractionEvents = + objc.registerName("endIgnoringInteractionEvents"); +late final _sel_isIgnoringInteractionEvents = + objc.registerName("isIgnoringInteractionEvents"); +final _objc_msgSend_5 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isIdleTimerDisabled = objc.registerName("isIdleTimerDisabled"); +late final _sel_setIdleTimerDisabled_ = + objc.registerName("setIdleTimerDisabled:"); +final _objc_msgSend_6 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, bool)>(); +late final _sel_openURL_ = objc.registerName("openURL:"); +final _objc_msgSend_7 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_canOpenURL_ = objc.registerName("canOpenURL:"); +void _ObjCBlock_ffiVoid_bool_fnPtrTrampoline( + ffi.Pointer block, bool arg0) => + block.ref.target + .cast>() + .asFunction()(arg0); +void _ObjCBlock_ffiVoid_bool_closureTrampoline( + ffi.Pointer block, bool arg0) => + (objc.getBlockClosure(block) as void Function(bool))(arg0); + +class ObjCBlock_ffiVoid_bool extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_bool._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_bool castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_bool._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_bool.fromFunctionPointer( + ffi.Pointer> ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Bool)>(_ObjCBlock_ffiVoid_bool_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_bool.fromFunction(void Function(bool) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Bool)>(_ObjCBlock_ffiVoid_bool_closureTrampoline) + .cast(), + (bool arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_bool.listener(void Function(bool) fn) + : this._((objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Bool)>.listener( + _ObjCBlock_ffiVoid_bool_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (bool arg0) => fn(arg0)))); + static ffi + .NativeCallable, ffi.Bool)>? + _dartFuncListenerTrampoline; + + void call(bool arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, ffi.Bool arg0)>>() + .asFunction, bool)>()( + pointer, arg0); +} + +late final _sel_openURL_options_completionHandler_ = + objc.registerName("openURL:options:completionHandler:"); +final _objc_msgSend_8 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// UIEvent +class UIEvent extends objc.NSObject { + UIEvent._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIEvent] that points to the same underlying object as [other]. + UIEvent.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIEvent] that wraps the given raw object pointer. + UIEvent.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIEvent]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIEvent); + } + + /// type + UIEventType get type { + final _ret = _objc_msgSend_9(this.pointer, _sel_type); + return UIEventType.fromValue(_ret); + } + + /// subtype + UIEventSubtype get subtype { + final _ret = _objc_msgSend_10(this.pointer, _sel_subtype); + return UIEventSubtype.fromValue(_ret); + } + + /// timestamp + double get timestamp { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_timestamp) + : _objc_msgSend_11(this.pointer, _sel_timestamp); + } + + /// modifierFlags + UIKeyModifierFlags get modifierFlags { + final _ret = _objc_msgSend_12(this.pointer, _sel_modifierFlags); + return UIKeyModifierFlags.fromValue(_ret); + } + + /// buttonMask + UIEventButtonMask get buttonMask { + final _ret = _objc_msgSend_13(this.pointer, _sel_buttonMask); + return UIEventButtonMask.fromValue(_ret); + } + + /// allTouches + objc.ObjCObjectBase? get allTouches { + final _ret = _objc_msgSend_2(this.pointer, _sel_allTouches); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// touchesForWindow: + objc.ObjCObjectBase? touchesForWindow_(UIWindow window) { + final _ret = + _objc_msgSend_567(this.pointer, _sel_touchesForWindow_, window.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// touchesForView: + objc.NSSet? touchesForView_(UIView view) { + final _ret = + _objc_msgSend_568(this.pointer, _sel_touchesForView_, view.pointer); + return _ret.address == 0 + ? null + : objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// touchesForGestureRecognizer: + objc.NSSet? touchesForGestureRecognizer_(UIGestureRecognizer gesture) { + final _ret = _objc_msgSend_569( + this.pointer, _sel_touchesForGestureRecognizer_, gesture.pointer); + return _ret.address == 0 + ? null + : objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// coalescedTouchesForTouch: + objc.NSArray? coalescedTouchesForTouch_(UITouch touch) { + final _ret = _objc_msgSend_570( + this.pointer, _sel_coalescedTouchesForTouch_, touch.pointer); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// predictedTouchesForTouch: + objc.NSArray? predictedTouchesForTouch_(UITouch touch) { + final _ret = _objc_msgSend_570( + this.pointer, _sel_predictedTouchesForTouch_, touch.pointer); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIEvent init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIEvent new1() { + final _ret = _objc_msgSend_18(_class_UIEvent, _sel_new); + return UIEvent.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIEvent allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIEvent, _sel_allocWithZone_, zone); + return UIEvent.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIEvent alloc() { + final _ret = _objc_msgSend_18(_class_UIEvent, _sel_alloc); + return UIEvent.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIEvent = objc.getClass("UIEvent"); + +enum UIEventType { + UIEventTypeTouches(0), + UIEventTypeMotion(1), + UIEventTypeRemoteControl(2), + UIEventTypePresses(3), + UIEventTypeScroll(10), + UIEventTypeHover(11), + UIEventTypeTransform(14); + + final int value; + const UIEventType(this.value); + + static UIEventType fromValue(int value) => switch (value) { + 0 => UIEventTypeTouches, + 1 => UIEventTypeMotion, + 2 => UIEventTypeRemoteControl, + 3 => UIEventTypePresses, + 10 => UIEventTypeScroll, + 11 => UIEventTypeHover, + 14 => UIEventTypeTransform, + _ => throw ArgumentError("Unknown value for UIEventType: $value"), + }; +} + +late final _sel_type = objc.registerName("type"); +final _objc_msgSend_9 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIEventSubtype { + UIEventSubtypeNone(0), + UIEventSubtypeMotionShake(1), + UIEventSubtypeRemoteControlPlay(100), + UIEventSubtypeRemoteControlPause(101), + UIEventSubtypeRemoteControlStop(102), + UIEventSubtypeRemoteControlTogglePlayPause(103), + UIEventSubtypeRemoteControlNextTrack(104), + UIEventSubtypeRemoteControlPreviousTrack(105), + UIEventSubtypeRemoteControlBeginSeekingBackward(106), + UIEventSubtypeRemoteControlEndSeekingBackward(107), + UIEventSubtypeRemoteControlBeginSeekingForward(108), + UIEventSubtypeRemoteControlEndSeekingForward(109); + + final int value; + const UIEventSubtype(this.value); + + static UIEventSubtype fromValue(int value) => switch (value) { + 0 => UIEventSubtypeNone, + 1 => UIEventSubtypeMotionShake, + 100 => UIEventSubtypeRemoteControlPlay, + 101 => UIEventSubtypeRemoteControlPause, + 102 => UIEventSubtypeRemoteControlStop, + 103 => UIEventSubtypeRemoteControlTogglePlayPause, + 104 => UIEventSubtypeRemoteControlNextTrack, + 105 => UIEventSubtypeRemoteControlPreviousTrack, + 106 => UIEventSubtypeRemoteControlBeginSeekingBackward, + 107 => UIEventSubtypeRemoteControlEndSeekingBackward, + 108 => UIEventSubtypeRemoteControlBeginSeekingForward, + 109 => UIEventSubtypeRemoteControlEndSeekingForward, + _ => throw ArgumentError("Unknown value for UIEventSubtype: $value"), + }; +} + +late final _sel_subtype = objc.registerName("subtype"); +final _objc_msgSend_10 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_timestamp = objc.registerName("timestamp"); +final _objc_msgSend_11 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Double Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_11Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Double Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIKeyModifierFlags { + UIKeyModifierAlphaShift(65536), + UIKeyModifierShift(131072), + UIKeyModifierControl(262144), + UIKeyModifierAlternate(524288), + UIKeyModifierCommand(1048576), + UIKeyModifierNumericPad(2097152); + + final int value; + const UIKeyModifierFlags(this.value); + + static UIKeyModifierFlags fromValue(int value) => switch (value) { + 65536 => UIKeyModifierAlphaShift, + 131072 => UIKeyModifierShift, + 262144 => UIKeyModifierControl, + 524288 => UIKeyModifierAlternate, + 1048576 => UIKeyModifierCommand, + 2097152 => UIKeyModifierNumericPad, + _ => + throw ArgumentError("Unknown value for UIKeyModifierFlags: $value"), + }; +} + +late final _sel_modifierFlags = objc.registerName("modifierFlags"); +final _objc_msgSend_12 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIEventButtonMask { + UIEventButtonMaskPrimary(1), + UIEventButtonMaskSecondary(2); + + final int value; + const UIEventButtonMask(this.value); + + static UIEventButtonMask fromValue(int value) => switch (value) { + 1 => UIEventButtonMaskPrimary, + 2 => UIEventButtonMaskSecondary, + _ => throw ArgumentError("Unknown value for UIEventButtonMask: $value"), + }; +} + +late final _sel_buttonMask = objc.registerName("buttonMask"); +final _objc_msgSend_13 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_allTouches = objc.registerName("allTouches"); + +/// UIWindow +class UIWindow extends UIView { + UIWindow._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIWindow] that points to the same underlying object as [other]. + UIWindow.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIWindow] that wraps the given raw object pointer. + UIWindow.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIWindow]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIWindow); + } + + /// initWithWindowScene: + UIWindow initWithWindowScene_(UIWindowScene windowScene) { + final _ret = _objc_msgSend_559( + this.pointer, _sel_initWithWindowScene_, windowScene.pointer); + return UIWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// windowScene + UIWindowScene? get windowScene { + final _ret = _objc_msgSend_560(this.pointer, _sel_windowScene); + return _ret.address == 0 + ? null + : UIWindowScene.castFromPointer(_ret, retain: true, release: true); + } + + /// setWindowScene: + set windowScene(UIWindowScene? value) { + return _objc_msgSend_561( + this.pointer, _sel_setWindowScene_, value?.pointer ?? ffi.nullptr); + } + + /// canResizeToFitContent + bool get canResizeToFitContent { + return _objc_msgSend_5(this.pointer, _sel_canResizeToFitContent); + } + + /// setCanResizeToFitContent: + set canResizeToFitContent(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setCanResizeToFitContent_, value); + } + + /// screen + UIScreen get screen { + final _ret = _objc_msgSend_15(this.pointer, _sel_screen); + return UIScreen.castFromPointer(_ret, retain: true, release: true); + } + + /// setScreen: + set screen(UIScreen value) { + return _objc_msgSend_562(this.pointer, _sel_setScreen_, value.pointer); + } + + /// windowLevel + double get windowLevel { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_windowLevel) + : _objc_msgSend_11(this.pointer, _sel_windowLevel); + } + + /// setWindowLevel: + set windowLevel(double value) { + return _objc_msgSend_26(this.pointer, _sel_setWindowLevel_, value); + } + + /// isKeyWindow + bool get keyWindow { + return _objc_msgSend_5(this.pointer, _sel_isKeyWindow); + } + + /// canBecomeKeyWindow + bool get canBecomeKeyWindow { + return _objc_msgSend_5(this.pointer, _sel_canBecomeKeyWindow); + } + + /// becomeKeyWindow + void becomeKeyWindow() { + _objc_msgSend_4(this.pointer, _sel_becomeKeyWindow); + } + + /// resignKeyWindow + void resignKeyWindow() { + _objc_msgSend_4(this.pointer, _sel_resignKeyWindow); + } + + /// makeKeyWindow + void makeKeyWindow() { + _objc_msgSend_4(this.pointer, _sel_makeKeyWindow); + } + + /// makeKeyAndVisible + void makeKeyAndVisible() { + _objc_msgSend_4(this.pointer, _sel_makeKeyAndVisible); + } + + /// rootViewController + UIViewController? get rootViewController { + final _ret = _objc_msgSend_404(this.pointer, _sel_rootViewController); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// setRootViewController: + set rootViewController(UIViewController? value) { + return _objc_msgSend_563(this.pointer, _sel_setRootViewController_, + value?.pointer ?? ffi.nullptr); + } + + /// sendEvent: + void sendEvent_(UIEvent event) { + _objc_msgSend_564(this.pointer, _sel_sendEvent_, event.pointer); + } + + /// convertPoint:toWindow: + void convertPoint_toWindow_( + ffi.Pointer stret, CGPoint point, UIWindow? window) { + objc.useMsgSendVariants + ? _objc_msgSend_565Stret(stret, this.pointer, + _sel_convertPoint_toWindow_, point, window?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_565(this.pointer, + _sel_convertPoint_toWindow_, point, window?.pointer ?? ffi.nullptr); + } + + /// convertPoint:fromWindow: + void convertPoint_fromWindow_( + ffi.Pointer stret, CGPoint point, UIWindow? window) { + objc.useMsgSendVariants + ? _objc_msgSend_565Stret( + stret, + this.pointer, + _sel_convertPoint_fromWindow_, + point, + window?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_565( + this.pointer, + _sel_convertPoint_fromWindow_, + point, + window?.pointer ?? ffi.nullptr); + } + + /// convertRect:toWindow: + void convertRect_toWindow_( + ffi.Pointer stret, CGRect rect, UIWindow? window) { + objc.useMsgSendVariants + ? _objc_msgSend_566Stret(stret, this.pointer, + _sel_convertRect_toWindow_, rect, window?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_566(this.pointer, + _sel_convertRect_toWindow_, rect, window?.pointer ?? ffi.nullptr); + } + + /// convertRect:fromWindow: + void convertRect_fromWindow_( + ffi.Pointer stret, CGRect rect, UIWindow? window) { + objc.useMsgSendVariants + ? _objc_msgSend_566Stret(stret, this.pointer, + _sel_convertRect_fromWindow_, rect, window?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_566(this.pointer, + _sel_convertRect_fromWindow_, rect, window?.pointer ?? ffi.nullptr); + } + + /// layerClass + static objc.ObjCObjectBase getLayerClass() { + final _ret = _objc_msgSend_18(_class_UIWindow, _sel_layerClass); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// initWithFrame: + UIWindow initWithFrame_(CGRect frame) { + final _ret = _objc_msgSend_54(this.pointer, _sel_initWithFrame_, frame); + return UIWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIWindow? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_( + UISemanticContentAttribute attribute) { + final _ret = _objc_msgSend_111( + _class_UIWindow, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_, + attribute.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute:relativeToLayoutDirection: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_( + UISemanticContentAttribute semanticContentAttribute, + UIUserInterfaceLayoutDirection layoutDirection) { + final _ret = _objc_msgSend_112( + _class_UIWindow, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_, + semanticContentAttribute.value, + layoutDirection.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// init + UIWindow init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIWindow new1() { + final _ret = _objc_msgSend_18(_class_UIWindow, _sel_new); + return UIWindow.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIWindow allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIWindow, _sel_allocWithZone_, zone); + return UIWindow.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIWindow alloc() { + final _ret = _objc_msgSend_18(_class_UIWindow, _sel_alloc); + return UIWindow.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIWindow = objc.getClass("UIWindow"); +typedef instancetype = ffi.Pointer; +typedef Dartinstancetype = objc.ObjCObjectBase; + +/// UIWindowScene +class UIWindowScene extends UIScene { + UIWindowScene._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIWindowScene] that points to the same underlying object as [other]. + UIWindowScene.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIWindowScene] that wraps the given raw object pointer. + UIWindowScene.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIWindowScene]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIWindowScene); + } + + /// screen + UIScreen get screen { + final _ret = _objc_msgSend_15(this.pointer, _sel_screen); + return UIScreen.castFromPointer(_ret, retain: true, release: true); + } + + /// interfaceOrientation + UIInterfaceOrientation get interfaceOrientation { + final _ret = _objc_msgSend_376(this.pointer, _sel_interfaceOrientation); + return UIInterfaceOrientation.fromValue(_ret); + } + + /// coordinateSpace + objc.ObjCObjectBase get coordinateSpace { + final _ret = _objc_msgSend_18(this.pointer, _sel_coordinateSpace); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// traitCollection + UITraitCollection get traitCollection { + final _ret = _objc_msgSend_299(this.pointer, _sel_traitCollection); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// requestGeometryUpdateWithPreferences:errorHandler: + void requestGeometryUpdateWithPreferences_errorHandler_( + UIWindowSceneGeometryPreferences geometryPreferences, + ObjCBlock_ffiVoid_NSError? errorHandler) { + _objc_msgSend_377( + this.pointer, + _sel_requestGeometryUpdateWithPreferences_errorHandler_, + geometryPreferences.pointer, + errorHandler?.pointer ?? ffi.nullptr); + } + + /// effectiveGeometry + UIWindowSceneGeometry get effectiveGeometry { + final _ret = _objc_msgSend_379(this.pointer, _sel_effectiveGeometry); + return UIWindowSceneGeometry.castFromPointer(_ret, + retain: true, release: true); + } + + /// sizeRestrictions + UISceneSizeRestrictions? get sizeRestrictions { + final _ret = _objc_msgSend_380(this.pointer, _sel_sizeRestrictions); + return _ret.address == 0 + ? null + : UISceneSizeRestrictions.castFromPointer(_ret, + retain: true, release: true); + } + + /// windows + objc.NSArray get windows { + final _ret = _objc_msgSend_14(this.pointer, _sel_windows); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// keyWindow + UIWindow? get keyWindow { + final _ret = _objc_msgSend_381(this.pointer, _sel_keyWindow); + return _ret.address == 0 + ? null + : UIWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// activityItemsConfigurationSource + objc.ObjCObjectBase? get activityItemsConfigurationSource { + final _ret = + _objc_msgSend_2(this.pointer, _sel_activityItemsConfigurationSource); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setActivityItemsConfigurationSource: + set activityItemsConfigurationSource(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, + _sel_setActivityItemsConfigurationSource_, + value?.pointer ?? ffi.nullptr); + } + + /// windowingBehaviors + UISceneWindowingBehaviors? get windowingBehaviors { + final _ret = _objc_msgSend_382(this.pointer, _sel_windowingBehaviors); + return _ret.address == 0 + ? null + : UISceneWindowingBehaviors.castFromPointer(_ret, + retain: true, release: true); + } + + /// isFullScreen + bool get fullScreen { + return _objc_msgSend_5(this.pointer, _sel_isFullScreen); + } + + /// new + static UIWindowScene new1() { + final _ret = _objc_msgSend_18(_class_UIWindowScene, _sel_new); + return UIWindowScene.castFromPointer(_ret, retain: false, release: true); + } + + /// init + UIWindowScene init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIWindowScene.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithSession:connectionOptions: + UIWindowScene initWithSession_connectionOptions_( + UISceneSession session, UISceneConnectionOptions connectionOptions) { + final _ret = _objc_msgSend_539( + this.pointer, + _sel_initWithSession_connectionOptions_, + session.pointer, + connectionOptions.pointer); + return UIWindowScene.castFromPointer(_ret, retain: true, release: true); + } + + /// allocWithZone: + static UIWindowScene allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIWindowScene, _sel_allocWithZone_, zone); + return UIWindowScene.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIWindowScene alloc() { + final _ret = _objc_msgSend_18(_class_UIWindowScene, _sel_alloc); + return UIWindowScene.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIWindowScene = objc.getClass("UIWindowScene"); + +/// UIScreen +class UIScreen extends objc.NSObject { + UIScreen._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIScreen] that points to the same underlying object as [other]. + UIScreen.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIScreen] that wraps the given raw object pointer. + UIScreen.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIScreen]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIScreen); + } + + /// screens + static objc.NSArray getScreens() { + final _ret = _objc_msgSend_14(_class_UIScreen, _sel_screens); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// mainScreen + static UIScreen getMainScreen() { + final _ret = _objc_msgSend_15(_class_UIScreen, _sel_mainScreen); + return UIScreen.castFromPointer(_ret, retain: true, release: true); + } + + /// bounds + void getBounds(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_bounds) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_bounds); + } + + /// scale + double get scale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_scale) + : _objc_msgSend_11(this.pointer, _sel_scale); + } + + /// availableModes + objc.NSArray get availableModes { + final _ret = _objc_msgSend_14(this.pointer, _sel_availableModes); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// preferredMode + UIScreenMode? get preferredMode { + final _ret = _objc_msgSend_20(this.pointer, _sel_preferredMode); + return _ret.address == 0 + ? null + : UIScreenMode.castFromPointer(_ret, retain: true, release: true); + } + + /// currentMode + UIScreenMode? get currentMode { + final _ret = _objc_msgSend_20(this.pointer, _sel_currentMode); + return _ret.address == 0 + ? null + : UIScreenMode.castFromPointer(_ret, retain: true, release: true); + } + + /// setCurrentMode: + set currentMode(UIScreenMode? value) { + return _objc_msgSend_21( + this.pointer, _sel_setCurrentMode_, value?.pointer ?? ffi.nullptr); + } + + /// overscanCompensation + UIScreenOverscanCompensation get overscanCompensation { + final _ret = _objc_msgSend_22(this.pointer, _sel_overscanCompensation); + return UIScreenOverscanCompensation.fromValue(_ret); + } + + /// setOverscanCompensation: + set overscanCompensation(UIScreenOverscanCompensation value) { + return _objc_msgSend_23( + this.pointer, _sel_setOverscanCompensation_, value.value); + } + + /// overscanCompensationInsets + void getOverscanCompensationInsets(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_24Stret( + stret, this.pointer, _sel_overscanCompensationInsets) + : stret.ref = + _objc_msgSend_24(this.pointer, _sel_overscanCompensationInsets); + } + + /// mirroredScreen + UIScreen? get mirroredScreen { + final _ret = _objc_msgSend_25(this.pointer, _sel_mirroredScreen); + return _ret.address == 0 + ? null + : UIScreen.castFromPointer(_ret, retain: true, release: true); + } + + /// isCaptured + bool get captured { + return _objc_msgSend_5(this.pointer, _sel_isCaptured); + } + + /// brightness + double get brightness { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_brightness) + : _objc_msgSend_11(this.pointer, _sel_brightness); + } + + /// setBrightness: + set brightness(double value) { + return _objc_msgSend_26(this.pointer, _sel_setBrightness_, value); + } + + /// wantsSoftwareDimming + bool get wantsSoftwareDimming { + return _objc_msgSend_5(this.pointer, _sel_wantsSoftwareDimming); + } + + /// setWantsSoftwareDimming: + set wantsSoftwareDimming(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setWantsSoftwareDimming_, value); + } + + /// coordinateSpace + objc.ObjCObjectBase get coordinateSpace { + final _ret = _objc_msgSend_18(this.pointer, _sel_coordinateSpace); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// fixedCoordinateSpace + objc.ObjCObjectBase get fixedCoordinateSpace { + final _ret = _objc_msgSend_18(this.pointer, _sel_fixedCoordinateSpace); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// nativeBounds + void getNativeBounds(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_nativeBounds) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_nativeBounds); + } + + /// nativeScale + double get nativeScale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_nativeScale) + : _objc_msgSend_11(this.pointer, _sel_nativeScale); + } + + /// displayLinkWithTarget:selector: + CADisplayLink? displayLinkWithTarget_selector_( + objc.ObjCObjectBase target, ffi.Pointer sel) { + final _ret = _objc_msgSend_52(this.pointer, + _sel_displayLinkWithTarget_selector_, target.pointer, sel); + return _ret.address == 0 + ? null + : CADisplayLink.castFromPointer(_ret, retain: true, release: true); + } + + /// maximumFramesPerSecond + int get maximumFramesPerSecond { + return _objc_msgSend_48(this.pointer, _sel_maximumFramesPerSecond); + } + + /// calibratedLatency + double get calibratedLatency { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_calibratedLatency) + : _objc_msgSend_11(this.pointer, _sel_calibratedLatency); + } + + /// referenceDisplayModeStatus + UIScreenReferenceDisplayModeStatus get referenceDisplayModeStatus { + final _ret = + _objc_msgSend_53(this.pointer, _sel_referenceDisplayModeStatus); + return UIScreenReferenceDisplayModeStatus.fromValue(_ret); + } + + /// currentEDRHeadroom + double get currentEDRHeadroom { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_currentEDRHeadroom) + : _objc_msgSend_11(this.pointer, _sel_currentEDRHeadroom); + } + + /// potentialEDRHeadroom + double get potentialEDRHeadroom { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_potentialEDRHeadroom) + : _objc_msgSend_11(this.pointer, _sel_potentialEDRHeadroom); + } + + /// focusedItem + objc.ObjCObjectBase? get focusedItem { + final _ret = _objc_msgSend_2(this.pointer, _sel_focusedItem); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// focusedView + UIView? get focusedView { + final _ret = _objc_msgSend_123(this.pointer, _sel_focusedView); + return _ret.address == 0 + ? null + : UIView.castFromPointer(_ret, retain: true, release: true); + } + + /// supportsFocus + bool get supportsFocus { + return _objc_msgSend_5(this.pointer, _sel_supportsFocus); + } + + /// applicationFrame + void getApplicationFrame(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_applicationFrame) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_applicationFrame); + } + + /// init + UIScreen init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIScreen.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIScreen new1() { + final _ret = _objc_msgSend_18(_class_UIScreen, _sel_new); + return UIScreen.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIScreen allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIScreen, _sel_allocWithZone_, zone); + return UIScreen.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIScreen alloc() { + final _ret = _objc_msgSend_18(_class_UIScreen, _sel_alloc); + return UIScreen.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIScreen = objc.getClass("UIScreen"); +late final _sel_screens = objc.registerName("screens"); +final _objc_msgSend_14 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_mainScreen = objc.registerName("mainScreen"); +final _objc_msgSend_15 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +final class CGRect extends ffi.Struct { + external CGPoint origin; + + external CGSize size; +} + +final class CGPoint extends ffi.Struct { + @ffi.Double() + external double x; + + @ffi.Double() + external double y; +} + +final class CGSize extends ffi.Struct { + @ffi.Double() + external double width; + + @ffi.Double() + external double height; +} + +late final _sel_bounds = objc.registerName("bounds"); +final _objc_msgSend_16 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGRect Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_16Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); +late final _sel_scale = objc.registerName("scale"); +late final _sel_availableModes = objc.registerName("availableModes"); + +/// UIScreenMode +class UIScreenMode extends objc.NSObject { + UIScreenMode._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIScreenMode] that points to the same underlying object as [other]. + UIScreenMode.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIScreenMode] that wraps the given raw object pointer. + UIScreenMode.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIScreenMode]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIScreenMode); + } + + /// size + void getSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_size) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_size); + } + + /// pixelAspectRatio + double get pixelAspectRatio { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_pixelAspectRatio) + : _objc_msgSend_11(this.pointer, _sel_pixelAspectRatio); + } + + /// init + UIScreenMode init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIScreenMode.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIScreenMode new1() { + final _ret = _objc_msgSend_18(_class_UIScreenMode, _sel_new); + return UIScreenMode.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIScreenMode allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIScreenMode, _sel_allocWithZone_, zone); + return UIScreenMode.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIScreenMode alloc() { + final _ret = _objc_msgSend_18(_class_UIScreenMode, _sel_alloc); + return UIScreenMode.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIScreenMode = objc.getClass("UIScreenMode"); +late final _sel_size = objc.registerName("size"); +final _objc_msgSend_17 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGSize Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGSize Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_17Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pixelAspectRatio = objc.registerName("pixelAspectRatio"); +late final _sel_init = objc.registerName("init"); +final _objc_msgSend_18 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_new = objc.registerName("new"); + +final class _NSZone extends ffi.Opaque {} + +late final _sel_allocWithZone_ = objc.registerName("allocWithZone:"); +final _objc_msgSend_19 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<_NSZone>)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<_NSZone>)>(); +late final _sel_alloc = objc.registerName("alloc"); +final _objc_msgSend_0 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isKindOfClass_ = objc.registerName("isKindOfClass:"); +late final _sel_preferredMode = objc.registerName("preferredMode"); +final _objc_msgSend_20 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_currentMode = objc.registerName("currentMode"); +late final _sel_setCurrentMode_ = objc.registerName("setCurrentMode:"); +final _objc_msgSend_21 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +enum UIScreenOverscanCompensation { + UIScreenOverscanCompensationScale(0), + UIScreenOverscanCompensationInsetBounds(1), + UIScreenOverscanCompensationNone(2); + + static const UIScreenOverscanCompensationInsetApplicationFrame = + UIScreenOverscanCompensationNone; + + final int value; + const UIScreenOverscanCompensation(this.value); + + static UIScreenOverscanCompensation fromValue(int value) => switch (value) { + 0 => UIScreenOverscanCompensationScale, + 1 => UIScreenOverscanCompensationInsetBounds, + 2 => UIScreenOverscanCompensationNone, + _ => throw ArgumentError( + "Unknown value for UIScreenOverscanCompensation: $value"), + }; + + @override + String toString() { + if (this == UIScreenOverscanCompensationNone) + return "UIScreenOverscanCompensation.UIScreenOverscanCompensationNone, UIScreenOverscanCompensation.UIScreenOverscanCompensationInsetApplicationFrame"; + return super.toString(); + } +} + +late final _sel_overscanCompensation = + objc.registerName("overscanCompensation"); +final _objc_msgSend_22 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setOverscanCompensation_ = + objc.registerName("setOverscanCompensation:"); +final _objc_msgSend_23 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +final class UIEdgeInsets extends ffi.Struct { + @ffi.Double() + external double top; + + @ffi.Double() + external double left; + + @ffi.Double() + external double bottom; + + @ffi.Double() + external double right; +} + +late final _sel_overscanCompensationInsets = + objc.registerName("overscanCompensationInsets"); +final _objc_msgSend_24 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + UIEdgeInsets Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + UIEdgeInsets Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_24Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); +late final _sel_mirroredScreen = objc.registerName("mirroredScreen"); +final _objc_msgSend_25 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isCaptured = objc.registerName("isCaptured"); +late final _sel_brightness = objc.registerName("brightness"); +late final _sel_setBrightness_ = objc.registerName("setBrightness:"); +final _objc_msgSend_26 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_wantsSoftwareDimming = + objc.registerName("wantsSoftwareDimming"); +late final _sel_setWantsSoftwareDimming_ = + objc.registerName("setWantsSoftwareDimming:"); +late final _sel_coordinateSpace = objc.registerName("coordinateSpace"); +late final _sel_fixedCoordinateSpace = + objc.registerName("fixedCoordinateSpace"); +late final _sel_nativeBounds = objc.registerName("nativeBounds"); +late final _sel_nativeScale = objc.registerName("nativeScale"); + +/// CADisplayLink +class CADisplayLink extends objc.NSObject { + CADisplayLink._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [CADisplayLink] that points to the same underlying object as [other]. + CADisplayLink.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CADisplayLink] that wraps the given raw object pointer. + CADisplayLink.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CADisplayLink]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_CADisplayLink); + } + + /// displayLinkWithTarget:selector: + static CADisplayLink displayLinkWithTarget_selector_( + objc.ObjCObjectBase target, ffi.Pointer sel) { + final _ret = _objc_msgSend_27(_class_CADisplayLink, + _sel_displayLinkWithTarget_selector_, target.pointer, sel); + return CADisplayLink.castFromPointer(_ret, retain: true, release: true); + } + + /// addToRunLoop:forMode: + void addToRunLoop_forMode_(NSRunLoop runloop, objc.NSString mode) { + _objc_msgSend_41(this.pointer, _sel_addToRunLoop_forMode_, runloop.pointer, + mode.pointer); + } + + /// removeFromRunLoop:forMode: + void removeFromRunLoop_forMode_(NSRunLoop runloop, objc.NSString mode) { + _objc_msgSend_41(this.pointer, _sel_removeFromRunLoop_forMode_, + runloop.pointer, mode.pointer); + } + + /// invalidate + void invalidate() { + _objc_msgSend_4(this.pointer, _sel_invalidate); + } + + /// timestamp + double get timestamp { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_timestamp) + : _objc_msgSend_11(this.pointer, _sel_timestamp); + } + + /// duration + double get duration { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_duration) + : _objc_msgSend_11(this.pointer, _sel_duration); + } + + /// targetTimestamp + double get targetTimestamp { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_targetTimestamp) + : _objc_msgSend_11(this.pointer, _sel_targetTimestamp); + } + + /// isPaused + bool get paused { + return _objc_msgSend_5(this.pointer, _sel_isPaused); + } + + /// setPaused: + set paused(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setPaused_, value); + } + + /// frameInterval + int get frameInterval { + return _objc_msgSend_48(this.pointer, _sel_frameInterval); + } + + /// setFrameInterval: + set frameInterval(int value) { + return _objc_msgSend_49(this.pointer, _sel_setFrameInterval_, value); + } + + /// preferredFramesPerSecond + int get preferredFramesPerSecond { + return _objc_msgSend_48(this.pointer, _sel_preferredFramesPerSecond); + } + + /// setPreferredFramesPerSecond: + set preferredFramesPerSecond(int value) { + return _objc_msgSend_49( + this.pointer, _sel_setPreferredFramesPerSecond_, value); + } + + /// preferredFrameRateRange + void getPreferredFrameRateRange(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_50Stret( + stret, this.pointer, _sel_preferredFrameRateRange) + : stret.ref = + _objc_msgSend_50(this.pointer, _sel_preferredFrameRateRange); + } + + /// setPreferredFrameRateRange: + set preferredFrameRateRange(CAFrameRateRange value) { + return _objc_msgSend_51( + this.pointer, _sel_setPreferredFrameRateRange_, value); + } + + /// init + CADisplayLink init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return CADisplayLink.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static CADisplayLink new1() { + final _ret = _objc_msgSend_18(_class_CADisplayLink, _sel_new); + return CADisplayLink.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static CADisplayLink allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_CADisplayLink, _sel_allocWithZone_, zone); + return CADisplayLink.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static CADisplayLink alloc() { + final _ret = _objc_msgSend_18(_class_CADisplayLink, _sel_alloc); + return CADisplayLink.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_CADisplayLink = objc.getClass("CADisplayLink"); +late final _sel_displayLinkWithTarget_selector_ = + objc.registerName("displayLinkWithTarget:selector:"); +final _objc_msgSend_27 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSRunLoop +class NSRunLoop extends objc.NSObject { + NSRunLoop._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSRunLoop] that points to the same underlying object as [other]. + NSRunLoop.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSRunLoop] that wraps the given raw object pointer. + NSRunLoop.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSRunLoop]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSRunLoop); + } + + /// currentRunLoop + static NSRunLoop getCurrentRunLoop() { + final _ret = _objc_msgSend_28(_class_NSRunLoop, _sel_currentRunLoop); + return NSRunLoop.castFromPointer(_ret, retain: true, release: true); + } + + /// mainRunLoop + static NSRunLoop getMainRunLoop() { + final _ret = _objc_msgSend_28(_class_NSRunLoop, _sel_mainRunLoop); + return NSRunLoop.castFromPointer(_ret, retain: true, release: true); + } + + /// currentMode + objc.NSString? get currentMode { + final _ret = _objc_msgSend_29(this.pointer, _sel_currentMode); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// getCFRunLoop + ffi.Pointer<__CFRunLoop> getCFRunLoop() { + return _objc_msgSend_30(this.pointer, _sel_getCFRunLoop); + } + + /// addTimer:forMode: + void addTimer_forMode_(NSTimer timer, objc.NSString mode) { + _objc_msgSend_38( + this.pointer, _sel_addTimer_forMode_, timer.pointer, mode.pointer); + } + + /// addPort:forMode: + void addPort_forMode_(NSPort aPort, objc.NSString mode) { + _objc_msgSend_45( + this.pointer, _sel_addPort_forMode_, aPort.pointer, mode.pointer); + } + + /// removePort:forMode: + void removePort_forMode_(NSPort aPort, objc.NSString mode) { + _objc_msgSend_45( + this.pointer, _sel_removePort_forMode_, aPort.pointer, mode.pointer); + } + + /// limitDateForMode: + objc.NSDate? limitDateForMode_(objc.NSString mode) { + final _ret = + _objc_msgSend_46(this.pointer, _sel_limitDateForMode_, mode.pointer); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// acceptInputForMode:beforeDate: + void acceptInputForMode_beforeDate_( + objc.NSString mode, objc.NSDate limitDate) { + _objc_msgSend_47(this.pointer, _sel_acceptInputForMode_beforeDate_, + mode.pointer, limitDate.pointer); + } + + /// init + NSRunLoop init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSRunLoop.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSRunLoop new1() { + final _ret = _objc_msgSend_18(_class_NSRunLoop, _sel_new); + return NSRunLoop.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSRunLoop allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_NSRunLoop, _sel_allocWithZone_, zone); + return NSRunLoop.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSRunLoop alloc() { + final _ret = _objc_msgSend_18(_class_NSRunLoop, _sel_alloc); + return NSRunLoop.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSRunLoop = objc.getClass("NSRunLoop"); +late final _sel_currentRunLoop = objc.registerName("currentRunLoop"); +final _objc_msgSend_28 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_mainRunLoop = objc.registerName("mainRunLoop"); +final _objc_msgSend_29 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +final class __CFRunLoop extends ffi.Opaque {} + +late final _sel_getCFRunLoop = objc.registerName("getCFRunLoop"); +final _objc_msgSend_30 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer<__CFRunLoop> Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer<__CFRunLoop> Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSTimer +class NSTimer extends objc.NSObject { + NSTimer._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSTimer] that points to the same underlying object as [other]. + NSTimer.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSTimer] that wraps the given raw object pointer. + NSTimer.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSTimer]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSTimer); + } + + /// timerWithTimeInterval:invocation:repeats: + static NSTimer timerWithTimeInterval_invocation_repeats_( + double ti, objc.NSInvocation invocation, bool yesOrNo) { + final _ret = _objc_msgSend_31( + _class_NSTimer, + _sel_timerWithTimeInterval_invocation_repeats_, + ti, + invocation.pointer, + yesOrNo); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// scheduledTimerWithTimeInterval:invocation:repeats: + static NSTimer scheduledTimerWithTimeInterval_invocation_repeats_( + double ti, objc.NSInvocation invocation, bool yesOrNo) { + final _ret = _objc_msgSend_31( + _class_NSTimer, + _sel_scheduledTimerWithTimeInterval_invocation_repeats_, + ti, + invocation.pointer, + yesOrNo); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// timerWithTimeInterval:target:selector:userInfo:repeats: + static NSTimer timerWithTimeInterval_target_selector_userInfo_repeats_( + double ti, + objc.ObjCObjectBase aTarget, + ffi.Pointer aSelector, + objc.ObjCObjectBase? userInfo, + bool yesOrNo) { + final _ret = _objc_msgSend_32( + _class_NSTimer, + _sel_timerWithTimeInterval_target_selector_userInfo_repeats_, + ti, + aTarget.pointer, + aSelector, + userInfo?.pointer ?? ffi.nullptr, + yesOrNo); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// scheduledTimerWithTimeInterval:target:selector:userInfo:repeats: + static NSTimer + scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_( + double ti, + objc.ObjCObjectBase aTarget, + ffi.Pointer aSelector, + objc.ObjCObjectBase? userInfo, + bool yesOrNo) { + final _ret = _objc_msgSend_32( + _class_NSTimer, + _sel_scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_, + ti, + aTarget.pointer, + aSelector, + userInfo?.pointer ?? ffi.nullptr, + yesOrNo); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// timerWithTimeInterval:repeats:block: + static NSTimer timerWithTimeInterval_repeats_block_( + double interval, bool repeats, ObjCBlock_ffiVoid_NSTimer block) { + final _ret = _objc_msgSend_33( + _class_NSTimer, + _sel_timerWithTimeInterval_repeats_block_, + interval, + repeats, + block.pointer); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// scheduledTimerWithTimeInterval:repeats:block: + static NSTimer scheduledTimerWithTimeInterval_repeats_block_( + double interval, bool repeats, ObjCBlock_ffiVoid_NSTimer block) { + final _ret = _objc_msgSend_33( + _class_NSTimer, + _sel_scheduledTimerWithTimeInterval_repeats_block_, + interval, + repeats, + block.pointer); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithFireDate:interval:repeats:block: + NSTimer initWithFireDate_interval_repeats_block_(objc.NSDate date, + double interval, bool repeats, ObjCBlock_ffiVoid_NSTimer block) { + final _ret = _objc_msgSend_34( + this.pointer, + _sel_initWithFireDate_interval_repeats_block_, + date.pointer, + interval, + repeats, + block.pointer); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithFireDate:interval:target:selector:userInfo:repeats: + NSTimer initWithFireDate_interval_target_selector_userInfo_repeats_( + objc.NSDate date, + double ti, + objc.ObjCObjectBase t, + ffi.Pointer s, + objc.ObjCObjectBase? ui, + bool rep) { + final _ret = _objc_msgSend_35( + this.pointer, + _sel_initWithFireDate_interval_target_selector_userInfo_repeats_, + date.pointer, + ti, + t.pointer, + s, + ui?.pointer ?? ffi.nullptr, + rep); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// fire + void fire() { + _objc_msgSend_4(this.pointer, _sel_fire); + } + + /// fireDate + objc.NSDate get fireDate { + final _ret = _objc_msgSend_36(this.pointer, _sel_fireDate); + return objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// setFireDate: + set fireDate(objc.NSDate value) { + return _objc_msgSend_37(this.pointer, _sel_setFireDate_, value.pointer); + } + + /// timeInterval + double get timeInterval { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_timeInterval) + : _objc_msgSend_11(this.pointer, _sel_timeInterval); + } + + /// tolerance + double get tolerance { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_tolerance) + : _objc_msgSend_11(this.pointer, _sel_tolerance); + } + + /// setTolerance: + set tolerance(double value) { + return _objc_msgSend_26(this.pointer, _sel_setTolerance_, value); + } + + /// invalidate + void invalidate() { + _objc_msgSend_4(this.pointer, _sel_invalidate); + } + + /// isValid + bool get valid { + return _objc_msgSend_5(this.pointer, _sel_isValid); + } + + /// userInfo + objc.ObjCObjectBase? get userInfo { + final _ret = _objc_msgSend_2(this.pointer, _sel_userInfo); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// init + NSTimer init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSTimer new1() { + final _ret = _objc_msgSend_18(_class_NSTimer, _sel_new); + return NSTimer.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSTimer allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_NSTimer, _sel_allocWithZone_, zone); + return NSTimer.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSTimer alloc() { + final _ret = _objc_msgSend_18(_class_NSTimer, _sel_alloc); + return NSTimer.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSTimer = objc.getClass("NSTimer"); +late final _sel_timerWithTimeInterval_invocation_repeats_ = + objc.registerName("timerWithTimeInterval:invocation:repeats:"); +final _objc_msgSend_31 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer, + bool)>(); +late final _sel_scheduledTimerWithTimeInterval_invocation_repeats_ = + objc.registerName("scheduledTimerWithTimeInterval:invocation:repeats:"); +late final _sel_timerWithTimeInterval_target_selector_userInfo_repeats_ = objc + .registerName("timerWithTimeInterval:target:selector:userInfo:repeats:"); +final _objc_msgSend_32 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_ = + objc.registerName( + "scheduledTimerWithTimeInterval:target:selector:userInfo:repeats:"); +void _ObjCBlock_ffiVoid_NSTimer_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_NSTimer_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_NSTimer extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSTimer._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSTimer castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSTimer._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSTimer.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSTimer_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSTimer.fromFunction(void Function(NSTimer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSTimer_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn( + NSTimer.castFromPointer(arg0, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSTimer.listener(void Function(NSTimer) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSTimer(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSTimer_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn( + NSTimer.castFromPointer(arg0, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(NSTimer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0.pointer); +} + +late final _sel_timerWithTimeInterval_repeats_block_ = + objc.registerName("timerWithTimeInterval:repeats:block:"); +final _objc_msgSend_33 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + double, + bool, + ffi.Pointer)>(); +late final _sel_scheduledTimerWithTimeInterval_repeats_block_ = + objc.registerName("scheduledTimerWithTimeInterval:repeats:block:"); +late final _sel_initWithFireDate_interval_repeats_block_ = + objc.registerName("initWithFireDate:interval:repeats:block:"); +final _objc_msgSend_34 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + bool, + ffi.Pointer)>(); +late final _sel_initWithFireDate_interval_target_selector_userInfo_repeats_ = + objc.registerName( + "initWithFireDate:interval:target:selector:userInfo:repeats:"); +final _objc_msgSend_35 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_fire = objc.registerName("fire"); +late final _sel_fireDate = objc.registerName("fireDate"); +final _objc_msgSend_36 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setFireDate_ = objc.registerName("setFireDate:"); +final _objc_msgSend_37 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_timeInterval = objc.registerName("timeInterval"); +late final _sel_tolerance = objc.registerName("tolerance"); +late final _sel_setTolerance_ = objc.registerName("setTolerance:"); +late final _sel_invalidate = objc.registerName("invalidate"); +late final _sel_isValid = objc.registerName("isValid"); +late final _sel_userInfo = objc.registerName("userInfo"); +late final _sel_addTimer_forMode_ = objc.registerName("addTimer:forMode:"); +final _objc_msgSend_38 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSPort +class NSPort extends objc.NSObject { + NSPort._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSPort] that points to the same underlying object as [other]. + NSPort.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSPort] that wraps the given raw object pointer. + NSPort.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSPort]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSPort); + } + + /// port + static NSPort port() { + final _ret = _objc_msgSend_39(_class_NSPort, _sel_port); + return NSPort.castFromPointer(_ret, retain: true, release: true); + } + + /// invalidate + void invalidate() { + _objc_msgSend_4(this.pointer, _sel_invalidate); + } + + /// isValid + bool get valid { + return _objc_msgSend_5(this.pointer, _sel_isValid); + } + + /// setDelegate: + void setDelegate_(objc.ObjCObjectBase? anObject) { + _objc_msgSend_40( + this.pointer, _sel_setDelegate_, anObject?.pointer ?? ffi.nullptr); + } + + /// delegate + objc.ObjCObjectBase? delegate() { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// scheduleInRunLoop:forMode: + void scheduleInRunLoop_forMode_(NSRunLoop runLoop, objc.NSString mode) { + _objc_msgSend_41(this.pointer, _sel_scheduleInRunLoop_forMode_, + runLoop.pointer, mode.pointer); + } + + /// removeFromRunLoop:forMode: + void removeFromRunLoop_forMode_(NSRunLoop runLoop, objc.NSString mode) { + _objc_msgSend_41(this.pointer, _sel_removeFromRunLoop_forMode_, + runLoop.pointer, mode.pointer); + } + + /// reservedSpaceLength + int get reservedSpaceLength { + return _objc_msgSend_42(this.pointer, _sel_reservedSpaceLength); + } + + /// sendBeforeDate:components:from:reserved: + bool sendBeforeDate_components_from_reserved_( + objc.NSDate limitDate, + objc.NSMutableArray? components, + NSPort? receivePort, + int headerSpaceReserved) { + return _objc_msgSend_43( + this.pointer, + _sel_sendBeforeDate_components_from_reserved_, + limitDate.pointer, + components?.pointer ?? ffi.nullptr, + receivePort?.pointer ?? ffi.nullptr, + headerSpaceReserved); + } + + /// sendBeforeDate:msgid:components:from:reserved: + bool sendBeforeDate_msgid_components_from_reserved_( + objc.NSDate limitDate, + int msgID, + objc.NSMutableArray? components, + NSPort? receivePort, + int headerSpaceReserved) { + return _objc_msgSend_44( + this.pointer, + _sel_sendBeforeDate_msgid_components_from_reserved_, + limitDate.pointer, + msgID, + components?.pointer ?? ffi.nullptr, + receivePort?.pointer ?? ffi.nullptr, + headerSpaceReserved); + } + + /// init + NSPort init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSPort.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSPort new1() { + final _ret = _objc_msgSend_18(_class_NSPort, _sel_new); + return NSPort.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSPort allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_NSPort, _sel_allocWithZone_, zone); + return NSPort.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSPort alloc() { + final _ret = _objc_msgSend_18(_class_NSPort, _sel_alloc); + return NSPort.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSPort = objc.getClass("NSPort"); +late final _sel_port = objc.registerName("port"); +final _objc_msgSend_39 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_40 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_scheduleInRunLoop_forMode_ = + objc.registerName("scheduleInRunLoop:forMode:"); +final _objc_msgSend_41 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removeFromRunLoop_forMode_ = + objc.registerName("removeFromRunLoop:forMode:"); +late final _sel_reservedSpaceLength = objc.registerName("reservedSpaceLength"); +final _objc_msgSend_42 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_sendBeforeDate_components_from_reserved_ = + objc.registerName("sendBeforeDate:components:from:reserved:"); +final _objc_msgSend_43 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_sendBeforeDate_msgid_components_from_reserved_ = + objc.registerName("sendBeforeDate:msgid:components:from:reserved:"); +final _objc_msgSend_44 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_addPort_forMode_ = objc.registerName("addPort:forMode:"); +final _objc_msgSend_45 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removePort_forMode_ = objc.registerName("removePort:forMode:"); +late final _sel_limitDateForMode_ = objc.registerName("limitDateForMode:"); +final _objc_msgSend_46 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_acceptInputForMode_beforeDate_ = + objc.registerName("acceptInputForMode:beforeDate:"); +final _objc_msgSend_47 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_addToRunLoop_forMode_ = + objc.registerName("addToRunLoop:forMode:"); +late final _sel_duration = objc.registerName("duration"); +late final _sel_targetTimestamp = objc.registerName("targetTimestamp"); +late final _sel_isPaused = objc.registerName("isPaused"); +late final _sel_setPaused_ = objc.registerName("setPaused:"); +late final _sel_frameInterval = objc.registerName("frameInterval"); +final _objc_msgSend_48 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setFrameInterval_ = objc.registerName("setFrameInterval:"); +final _objc_msgSend_49 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_preferredFramesPerSecond = + objc.registerName("preferredFramesPerSecond"); +late final _sel_setPreferredFramesPerSecond_ = + objc.registerName("setPreferredFramesPerSecond:"); + +final class CAFrameRateRange extends ffi.Struct { + @ffi.Float() + external double minimum; + + @ffi.Float() + external double maximum; + + @ffi.Float() + external double preferred; +} + +late final _sel_preferredFrameRateRange = + objc.registerName("preferredFrameRateRange"); +final _objc_msgSend_50 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CAFrameRateRange Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CAFrameRateRange Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_50Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setPreferredFrameRateRange_ = + objc.registerName("setPreferredFrameRateRange:"); +final _objc_msgSend_51 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CAFrameRateRange)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CAFrameRateRange)>(); +final _objc_msgSend_52 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_maximumFramesPerSecond = + objc.registerName("maximumFramesPerSecond"); +late final _sel_calibratedLatency = objc.registerName("calibratedLatency"); + +enum UIScreenReferenceDisplayModeStatus { + UIScreenReferenceDisplayModeStatusNotSupported(0), + UIScreenReferenceDisplayModeStatusNotEnabled(1), + UIScreenReferenceDisplayModeStatusLimited(2), + UIScreenReferenceDisplayModeStatusEnabled(3); + + final int value; + const UIScreenReferenceDisplayModeStatus(this.value); + + static UIScreenReferenceDisplayModeStatus fromValue(int value) => + switch (value) { + 0 => UIScreenReferenceDisplayModeStatusNotSupported, + 1 => UIScreenReferenceDisplayModeStatusNotEnabled, + 2 => UIScreenReferenceDisplayModeStatusLimited, + 3 => UIScreenReferenceDisplayModeStatusEnabled, + _ => throw ArgumentError( + "Unknown value for UIScreenReferenceDisplayModeStatus: $value"), + }; +} + +late final _sel_referenceDisplayModeStatus = + objc.registerName("referenceDisplayModeStatus"); +final _objc_msgSend_53 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_currentEDRHeadroom = objc.registerName("currentEDRHeadroom"); +late final _sel_potentialEDRHeadroom = + objc.registerName("potentialEDRHeadroom"); +late final _sel_focusedItem = objc.registerName("focusedItem"); + +/// UIView +class UIView extends UIResponder { + UIView._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIView] that points to the same underlying object as [other]. + UIView.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIView] that wraps the given raw object pointer. + UIView.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIView]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIView); + } + + /// layerClass + static objc.ObjCObjectBase getLayerClass() { + final _ret = _objc_msgSend_18(_class_UIView, _sel_layerClass); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// initWithFrame: + UIView initWithFrame_(CGRect frame) { + final _ret = _objc_msgSend_54(this.pointer, _sel_initWithFrame_, frame); + return UIView.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIView? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIView.castFromPointer(_ret, retain: true, release: true); + } + + /// isUserInteractionEnabled + bool get userInteractionEnabled { + return _objc_msgSend_5(this.pointer, _sel_isUserInteractionEnabled); + } + + /// setUserInteractionEnabled: + set userInteractionEnabled(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setUserInteractionEnabled_, value); + } + + /// tag + int get tag { + return _objc_msgSend_48(this.pointer, _sel_tag); + } + + /// setTag: + set tag(int value) { + return _objc_msgSend_49(this.pointer, _sel_setTag_, value); + } + + /// layer + CALayer get layer { + final _ret = _objc_msgSend_106(this.pointer, _sel_layer); + return CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// canBecomeFocused + bool get canBecomeFocused { + return _objc_msgSend_5(this.pointer, _sel_canBecomeFocused); + } + + /// isFocused + bool get focused { + return _objc_msgSend_5(this.pointer, _sel_isFocused); + } + + /// focusGroupIdentifier + objc.NSString? get focusGroupIdentifier { + final _ret = _objc_msgSend_29(this.pointer, _sel_focusGroupIdentifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setFocusGroupIdentifier: + set focusGroupIdentifier(objc.NSString? value) { + return _objc_msgSend_103(this.pointer, _sel_setFocusGroupIdentifier_, + value?.pointer ?? ffi.nullptr); + } + + /// focusGroupPriority + int get focusGroupPriority { + return _objc_msgSend_48(this.pointer, _sel_focusGroupPriority); + } + + /// setFocusGroupPriority: + set focusGroupPriority(int value) { + return _objc_msgSend_49(this.pointer, _sel_setFocusGroupPriority_, value); + } + + /// focusEffect + UIFocusEffect? get focusEffect { + final _ret = _objc_msgSend_107(this.pointer, _sel_focusEffect); + return _ret.address == 0 + ? null + : UIFocusEffect.castFromPointer(_ret, retain: true, release: true); + } + + /// setFocusEffect: + set focusEffect(UIFocusEffect? value) { + return _objc_msgSend_108( + this.pointer, _sel_setFocusEffect_, value?.pointer ?? ffi.nullptr); + } + + /// semanticContentAttribute + UISemanticContentAttribute get semanticContentAttribute { + final _ret = _objc_msgSend_109(this.pointer, _sel_semanticContentAttribute); + return UISemanticContentAttribute.fromValue(_ret); + } + + /// setSemanticContentAttribute: + set semanticContentAttribute(UISemanticContentAttribute value) { + return _objc_msgSend_110( + this.pointer, _sel_setSemanticContentAttribute_, value.value); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_( + UISemanticContentAttribute attribute) { + final _ret = _objc_msgSend_111( + _class_UIView, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_, + attribute.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute:relativeToLayoutDirection: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_( + UISemanticContentAttribute semanticContentAttribute, + UIUserInterfaceLayoutDirection layoutDirection) { + final _ret = _objc_msgSend_112( + _class_UIView, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_, + semanticContentAttribute.value, + layoutDirection.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// effectiveUserInterfaceLayoutDirection + UIUserInterfaceLayoutDirection get effectiveUserInterfaceLayoutDirection { + final _ret = _objc_msgSend_113( + this.pointer, _sel_effectiveUserInterfaceLayoutDirection); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// init + UIView init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIView.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIView new1() { + final _ret = _objc_msgSend_18(_class_UIView, _sel_new); + return UIView.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIView allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIView, _sel_allocWithZone_, zone); + return UIView.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIView alloc() { + final _ret = _objc_msgSend_18(_class_UIView, _sel_alloc); + return UIView.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIView = objc.getClass("UIView"); +late final _sel_layerClass = objc.registerName("layerClass"); +late final _sel_initWithFrame_ = objc.registerName("initWithFrame:"); +final _objc_msgSend_54 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_initWithCoder_ = objc.registerName("initWithCoder:"); +final _objc_msgSend_55 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isUserInteractionEnabled = + objc.registerName("isUserInteractionEnabled"); +late final _sel_setUserInteractionEnabled_ = + objc.registerName("setUserInteractionEnabled:"); +late final _sel_tag = objc.registerName("tag"); +late final _sel_setTag_ = objc.registerName("setTag:"); + +/// CALayer +class CALayer extends objc.NSObject { + CALayer._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [CALayer] that points to the same underlying object as [other]. + CALayer.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CALayer] that wraps the given raw object pointer. + CALayer.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CALayer]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_CALayer); + } + + /// layer + static CALayer layer() { + final _ret = _objc_msgSend_18(_class_CALayer, _sel_layer); + return CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// init + CALayer init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithLayer: + CALayer initWithLayer_(objc.ObjCObjectBase layer) { + final _ret = + _objc_msgSend_56(this.pointer, _sel_initWithLayer_, layer.pointer); + return CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// presentationLayer + CALayer? presentationLayer() { + final _ret = _objc_msgSend_2(this.pointer, _sel_presentationLayer); + return _ret.address == 0 + ? null + : CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// modelLayer + CALayer modelLayer() { + final _ret = _objc_msgSend_18(this.pointer, _sel_modelLayer); + return CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// defaultValueForKey: + static objc.ObjCObjectBase? defaultValueForKey_(objc.NSString key) { + final _ret = + _objc_msgSend_57(_class_CALayer, _sel_defaultValueForKey_, key.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// needsDisplayForKey: + static bool needsDisplayForKey_(objc.NSString key) { + return _objc_msgSend_58( + _class_CALayer, _sel_needsDisplayForKey_, key.pointer); + } + + /// shouldArchiveValueForKey: + bool shouldArchiveValueForKey_(objc.NSString key) { + return _objc_msgSend_58( + this.pointer, _sel_shouldArchiveValueForKey_, key.pointer); + } + + /// bounds + void getBounds(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_bounds) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_bounds); + } + + /// setBounds: + set bounds(CGRect value) { + return _objc_msgSend_59(this.pointer, _sel_setBounds_, value); + } + + /// position + void getPosition(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_60Stret(stret, this.pointer, _sel_position) + : stret.ref = _objc_msgSend_60(this.pointer, _sel_position); + } + + /// setPosition: + set position(CGPoint value) { + return _objc_msgSend_61(this.pointer, _sel_setPosition_, value); + } + + /// zPosition + double get zPosition { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_zPosition) + : _objc_msgSend_11(this.pointer, _sel_zPosition); + } + + /// setZPosition: + set zPosition(double value) { + return _objc_msgSend_26(this.pointer, _sel_setZPosition_, value); + } + + /// anchorPoint + void getAnchorPoint(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_60Stret(stret, this.pointer, _sel_anchorPoint) + : stret.ref = _objc_msgSend_60(this.pointer, _sel_anchorPoint); + } + + /// setAnchorPoint: + set anchorPoint(CGPoint value) { + return _objc_msgSend_61(this.pointer, _sel_setAnchorPoint_, value); + } + + /// anchorPointZ + double get anchorPointZ { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_anchorPointZ) + : _objc_msgSend_11(this.pointer, _sel_anchorPointZ); + } + + /// setAnchorPointZ: + set anchorPointZ(double value) { + return _objc_msgSend_26(this.pointer, _sel_setAnchorPointZ_, value); + } + + /// transform + void getTransform(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_62Stret(stret, this.pointer, _sel_transform) + : stret.ref = _objc_msgSend_62(this.pointer, _sel_transform); + } + + /// setTransform: + set transform(CATransform3D value) { + return _objc_msgSend_63(this.pointer, _sel_setTransform_, value); + } + + /// affineTransform + void affineTransform(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_64Stret(stret, this.pointer, _sel_affineTransform) + : stret.ref = _objc_msgSend_64(this.pointer, _sel_affineTransform); + } + + /// setAffineTransform: + void setAffineTransform_(CGAffineTransform m) { + _objc_msgSend_65(this.pointer, _sel_setAffineTransform_, m); + } + + /// frame + void getFrame(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_frame) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_frame); + } + + /// setFrame: + set frame(CGRect value) { + return _objc_msgSend_59(this.pointer, _sel_setFrame_, value); + } + + /// isHidden + bool get hidden { + return _objc_msgSend_5(this.pointer, _sel_isHidden); + } + + /// setHidden: + set hidden(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setHidden_, value); + } + + /// isDoubleSided + bool get doubleSided { + return _objc_msgSend_5(this.pointer, _sel_isDoubleSided); + } + + /// setDoubleSided: + set doubleSided(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setDoubleSided_, value); + } + + /// isGeometryFlipped + bool get geometryFlipped { + return _objc_msgSend_5(this.pointer, _sel_isGeometryFlipped); + } + + /// setGeometryFlipped: + set geometryFlipped(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setGeometryFlipped_, value); + } + + /// contentsAreFlipped + bool contentsAreFlipped() { + return _objc_msgSend_5(this.pointer, _sel_contentsAreFlipped); + } + + /// superlayer + CALayer? get superlayer { + final _ret = _objc_msgSend_66(this.pointer, _sel_superlayer); + return _ret.address == 0 + ? null + : CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// removeFromSuperlayer + void removeFromSuperlayer() { + _objc_msgSend_4(this.pointer, _sel_removeFromSuperlayer); + } + + /// sublayers + objc.ObjCObjectBase? get sublayers { + final _ret = _objc_msgSend_2(this.pointer, _sel_sublayers); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setSublayers: + set sublayers(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setSublayers_, value?.pointer ?? ffi.nullptr); + } + + /// addSublayer: + void addSublayer_(CALayer layer) { + _objc_msgSend_67(this.pointer, _sel_addSublayer_, layer.pointer); + } + + /// insertSublayer:atIndex: + void insertSublayer_atIndex_(CALayer layer, int idx) { + _objc_msgSend_68( + this.pointer, _sel_insertSublayer_atIndex_, layer.pointer, idx); + } + + /// insertSublayer:below: + void insertSublayer_below_(CALayer layer, CALayer? sibling) { + _objc_msgSend_69(this.pointer, _sel_insertSublayer_below_, layer.pointer, + sibling?.pointer ?? ffi.nullptr); + } + + /// insertSublayer:above: + void insertSublayer_above_(CALayer layer, CALayer? sibling) { + _objc_msgSend_69(this.pointer, _sel_insertSublayer_above_, layer.pointer, + sibling?.pointer ?? ffi.nullptr); + } + + /// replaceSublayer:with: + void replaceSublayer_with_(CALayer oldLayer, CALayer newLayer) { + _objc_msgSend_70(this.pointer, _sel_replaceSublayer_with_, oldLayer.pointer, + newLayer.pointer); + } + + /// sublayerTransform + void getSublayerTransform(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_62Stret(stret, this.pointer, _sel_sublayerTransform) + : stret.ref = _objc_msgSend_62(this.pointer, _sel_sublayerTransform); + } + + /// setSublayerTransform: + set sublayerTransform(CATransform3D value) { + return _objc_msgSend_63(this.pointer, _sel_setSublayerTransform_, value); + } + + /// mask + CALayer? get mask { + final _ret = _objc_msgSend_66(this.pointer, _sel_mask); + return _ret.address == 0 + ? null + : CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// setMask: + set mask(CALayer? value) { + return _objc_msgSend_71( + this.pointer, _sel_setMask_, value?.pointer ?? ffi.nullptr); + } + + /// masksToBounds + bool get masksToBounds { + return _objc_msgSend_5(this.pointer, _sel_masksToBounds); + } + + /// setMasksToBounds: + set masksToBounds(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setMasksToBounds_, value); + } + + /// convertPoint:fromLayer: + void convertPoint_fromLayer_( + ffi.Pointer stret, CGPoint p, CALayer? l) { + objc.useMsgSendVariants + ? _objc_msgSend_72Stret(stret, this.pointer, + _sel_convertPoint_fromLayer_, p, l?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_72(this.pointer, + _sel_convertPoint_fromLayer_, p, l?.pointer ?? ffi.nullptr); + } + + /// convertPoint:toLayer: + void convertPoint_toLayer_( + ffi.Pointer stret, CGPoint p, CALayer? l) { + objc.useMsgSendVariants + ? _objc_msgSend_72Stret(stret, this.pointer, _sel_convertPoint_toLayer_, + p, l?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_72(this.pointer, _sel_convertPoint_toLayer_, + p, l?.pointer ?? ffi.nullptr); + } + + /// convertRect:fromLayer: + void convertRect_fromLayer_(ffi.Pointer stret, CGRect r, CALayer? l) { + objc.useMsgSendVariants + ? _objc_msgSend_73Stret(stret, this.pointer, + _sel_convertRect_fromLayer_, r, l?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_73(this.pointer, + _sel_convertRect_fromLayer_, r, l?.pointer ?? ffi.nullptr); + } + + /// convertRect:toLayer: + void convertRect_toLayer_(ffi.Pointer stret, CGRect r, CALayer? l) { + objc.useMsgSendVariants + ? _objc_msgSend_73Stret(stret, this.pointer, _sel_convertRect_toLayer_, + r, l?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_73(this.pointer, _sel_convertRect_toLayer_, + r, l?.pointer ?? ffi.nullptr); + } + + /// convertTime:fromLayer: + double convertTime_fromLayer_(double t, CALayer? l) { + return objc.useMsgSendVariants + ? _objc_msgSend_74Fpret(this.pointer, _sel_convertTime_fromLayer_, t, + l?.pointer ?? ffi.nullptr) + : _objc_msgSend_74(this.pointer, _sel_convertTime_fromLayer_, t, + l?.pointer ?? ffi.nullptr); + } + + /// convertTime:toLayer: + double convertTime_toLayer_(double t, CALayer? l) { + return objc.useMsgSendVariants + ? _objc_msgSend_74Fpret(this.pointer, _sel_convertTime_toLayer_, t, + l?.pointer ?? ffi.nullptr) + : _objc_msgSend_74(this.pointer, _sel_convertTime_toLayer_, t, + l?.pointer ?? ffi.nullptr); + } + + /// hitTest: + CALayer? hitTest_(CGPoint p) { + final _ret = _objc_msgSend_75(this.pointer, _sel_hitTest_, p); + return _ret.address == 0 + ? null + : CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// containsPoint: + bool containsPoint_(CGPoint p) { + return _objc_msgSend_76(this.pointer, _sel_containsPoint_, p); + } + + /// contents + objc.ObjCObjectBase? get contents { + final _ret = _objc_msgSend_2(this.pointer, _sel_contents); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setContents: + set contents(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setContents_, value?.pointer ?? ffi.nullptr); + } + + /// contentsRect + void getContentsRect(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_contentsRect) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_contentsRect); + } + + /// setContentsRect: + set contentsRect(CGRect value) { + return _objc_msgSend_59(this.pointer, _sel_setContentsRect_, value); + } + + /// contentsGravity + objc.NSString get contentsGravity { + final _ret = _objc_msgSend_77(this.pointer, _sel_contentsGravity); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setContentsGravity: + set contentsGravity(objc.NSString value) { + return _objc_msgSend_78( + this.pointer, _sel_setContentsGravity_, value.pointer); + } + + /// contentsScale + double get contentsScale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_contentsScale) + : _objc_msgSend_11(this.pointer, _sel_contentsScale); + } + + /// setContentsScale: + set contentsScale(double value) { + return _objc_msgSend_26(this.pointer, _sel_setContentsScale_, value); + } + + /// contentsCenter + void getContentsCenter(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_contentsCenter) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_contentsCenter); + } + + /// setContentsCenter: + set contentsCenter(CGRect value) { + return _objc_msgSend_59(this.pointer, _sel_setContentsCenter_, value); + } + + /// contentsFormat + objc.NSString get contentsFormat { + final _ret = _objc_msgSend_77(this.pointer, _sel_contentsFormat); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setContentsFormat: + set contentsFormat(objc.NSString value) { + return _objc_msgSend_78( + this.pointer, _sel_setContentsFormat_, value.pointer); + } + + /// wantsExtendedDynamicRangeContent + bool get wantsExtendedDynamicRangeContent { + return _objc_msgSend_5(this.pointer, _sel_wantsExtendedDynamicRangeContent); + } + + /// setWantsExtendedDynamicRangeContent: + set wantsExtendedDynamicRangeContent(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setWantsExtendedDynamicRangeContent_, value); + } + + /// minificationFilter + objc.NSString get minificationFilter { + final _ret = _objc_msgSend_77(this.pointer, _sel_minificationFilter); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setMinificationFilter: + set minificationFilter(objc.NSString value) { + return _objc_msgSend_78( + this.pointer, _sel_setMinificationFilter_, value.pointer); + } + + /// magnificationFilter + objc.NSString get magnificationFilter { + final _ret = _objc_msgSend_77(this.pointer, _sel_magnificationFilter); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setMagnificationFilter: + set magnificationFilter(objc.NSString value) { + return _objc_msgSend_78( + this.pointer, _sel_setMagnificationFilter_, value.pointer); + } + + /// minificationFilterBias + double get minificationFilterBias { + return objc.useMsgSendVariants + ? _objc_msgSend_79Fpret(this.pointer, _sel_minificationFilterBias) + : _objc_msgSend_79(this.pointer, _sel_minificationFilterBias); + } + + /// setMinificationFilterBias: + set minificationFilterBias(double value) { + return _objc_msgSend_80( + this.pointer, _sel_setMinificationFilterBias_, value); + } + + /// isOpaque + bool get opaque { + return _objc_msgSend_5(this.pointer, _sel_isOpaque); + } + + /// setOpaque: + set opaque(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setOpaque_, value); + } + + /// display + void display() { + _objc_msgSend_4(this.pointer, _sel_display); + } + + /// setNeedsDisplay + void setNeedsDisplay() { + _objc_msgSend_4(this.pointer, _sel_setNeedsDisplay); + } + + /// setNeedsDisplayInRect: + void setNeedsDisplayInRect_(CGRect r) { + _objc_msgSend_81(this.pointer, _sel_setNeedsDisplayInRect_, r); + } + + /// needsDisplay + bool needsDisplay() { + return _objc_msgSend_5(this.pointer, _sel_needsDisplay); + } + + /// displayIfNeeded + void displayIfNeeded() { + _objc_msgSend_4(this.pointer, _sel_displayIfNeeded); + } + + /// needsDisplayOnBoundsChange + bool get needsDisplayOnBoundsChange { + return _objc_msgSend_5(this.pointer, _sel_needsDisplayOnBoundsChange); + } + + /// setNeedsDisplayOnBoundsChange: + set needsDisplayOnBoundsChange(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setNeedsDisplayOnBoundsChange_, value); + } + + /// drawsAsynchronously + bool get drawsAsynchronously { + return _objc_msgSend_5(this.pointer, _sel_drawsAsynchronously); + } + + /// setDrawsAsynchronously: + set drawsAsynchronously(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setDrawsAsynchronously_, value); + } + + /// drawInContext: + void drawInContext_(ffi.Pointer ctx) { + _objc_msgSend_82(this.pointer, _sel_drawInContext_, ctx); + } + + /// renderInContext: + void renderInContext_(ffi.Pointer ctx) { + _objc_msgSend_82(this.pointer, _sel_renderInContext_, ctx); + } + + /// edgeAntialiasingMask + CAEdgeAntialiasingMask get edgeAntialiasingMask { + final _ret = _objc_msgSend_83(this.pointer, _sel_edgeAntialiasingMask); + return CAEdgeAntialiasingMask.fromValue(_ret); + } + + /// setEdgeAntialiasingMask: + set edgeAntialiasingMask(CAEdgeAntialiasingMask value) { + return _objc_msgSend_84( + this.pointer, _sel_setEdgeAntialiasingMask_, value.value); + } + + /// allowsEdgeAntialiasing + bool get allowsEdgeAntialiasing { + return _objc_msgSend_5(this.pointer, _sel_allowsEdgeAntialiasing); + } + + /// setAllowsEdgeAntialiasing: + set allowsEdgeAntialiasing(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setAllowsEdgeAntialiasing_, value); + } + + /// backgroundColor + ffi.Pointer get backgroundColor { + return _objc_msgSend_85(this.pointer, _sel_backgroundColor); + } + + /// setBackgroundColor: + set backgroundColor(ffi.Pointer value) { + return _objc_msgSend_86(this.pointer, _sel_setBackgroundColor_, value); + } + + /// cornerRadius + double get cornerRadius { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_cornerRadius) + : _objc_msgSend_11(this.pointer, _sel_cornerRadius); + } + + /// setCornerRadius: + set cornerRadius(double value) { + return _objc_msgSend_26(this.pointer, _sel_setCornerRadius_, value); + } + + /// maskedCorners + CACornerMask get maskedCorners { + final _ret = _objc_msgSend_87(this.pointer, _sel_maskedCorners); + return CACornerMask.fromValue(_ret); + } + + /// setMaskedCorners: + set maskedCorners(CACornerMask value) { + return _objc_msgSend_88(this.pointer, _sel_setMaskedCorners_, value.value); + } + + /// cornerCurve + objc.NSString get cornerCurve { + final _ret = _objc_msgSend_77(this.pointer, _sel_cornerCurve); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setCornerCurve: + set cornerCurve(objc.NSString value) { + return _objc_msgSend_78(this.pointer, _sel_setCornerCurve_, value.pointer); + } + + /// cornerCurveExpansionFactor: + static double cornerCurveExpansionFactor_(objc.NSString curve) { + return objc.useMsgSendVariants + ? _objc_msgSend_89Fpret( + _class_CALayer, _sel_cornerCurveExpansionFactor_, curve.pointer) + : _objc_msgSend_89( + _class_CALayer, _sel_cornerCurveExpansionFactor_, curve.pointer); + } + + /// borderWidth + double get borderWidth { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_borderWidth) + : _objc_msgSend_11(this.pointer, _sel_borderWidth); + } + + /// setBorderWidth: + set borderWidth(double value) { + return _objc_msgSend_26(this.pointer, _sel_setBorderWidth_, value); + } + + /// borderColor + ffi.Pointer get borderColor { + return _objc_msgSend_85(this.pointer, _sel_borderColor); + } + + /// setBorderColor: + set borderColor(ffi.Pointer value) { + return _objc_msgSend_86(this.pointer, _sel_setBorderColor_, value); + } + + /// opacity + double get opacity { + return objc.useMsgSendVariants + ? _objc_msgSend_79Fpret(this.pointer, _sel_opacity) + : _objc_msgSend_79(this.pointer, _sel_opacity); + } + + /// setOpacity: + set opacity(double value) { + return _objc_msgSend_80(this.pointer, _sel_setOpacity_, value); + } + + /// allowsGroupOpacity + bool get allowsGroupOpacity { + return _objc_msgSend_5(this.pointer, _sel_allowsGroupOpacity); + } + + /// setAllowsGroupOpacity: + set allowsGroupOpacity(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setAllowsGroupOpacity_, value); + } + + /// compositingFilter + objc.ObjCObjectBase? get compositingFilter { + final _ret = _objc_msgSend_2(this.pointer, _sel_compositingFilter); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setCompositingFilter: + set compositingFilter(objc.ObjCObjectBase? value) { + return _objc_msgSend_3(this.pointer, _sel_setCompositingFilter_, + value?.pointer ?? ffi.nullptr); + } + + /// filters + objc.NSArray? get filters { + final _ret = _objc_msgSend_90(this.pointer, _sel_filters); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// setFilters: + set filters(objc.NSArray? value) { + return _objc_msgSend_91( + this.pointer, _sel_setFilters_, value?.pointer ?? ffi.nullptr); + } + + /// backgroundFilters + objc.NSArray? get backgroundFilters { + final _ret = _objc_msgSend_90(this.pointer, _sel_backgroundFilters); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// setBackgroundFilters: + set backgroundFilters(objc.NSArray? value) { + return _objc_msgSend_91(this.pointer, _sel_setBackgroundFilters_, + value?.pointer ?? ffi.nullptr); + } + + /// shouldRasterize + bool get shouldRasterize { + return _objc_msgSend_5(this.pointer, _sel_shouldRasterize); + } + + /// setShouldRasterize: + set shouldRasterize(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setShouldRasterize_, value); + } + + /// rasterizationScale + double get rasterizationScale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_rasterizationScale) + : _objc_msgSend_11(this.pointer, _sel_rasterizationScale); + } + + /// setRasterizationScale: + set rasterizationScale(double value) { + return _objc_msgSend_26(this.pointer, _sel_setRasterizationScale_, value); + } + + /// shadowColor + ffi.Pointer get shadowColor { + return _objc_msgSend_85(this.pointer, _sel_shadowColor); + } + + /// setShadowColor: + set shadowColor(ffi.Pointer value) { + return _objc_msgSend_86(this.pointer, _sel_setShadowColor_, value); + } + + /// shadowOpacity + double get shadowOpacity { + return objc.useMsgSendVariants + ? _objc_msgSend_79Fpret(this.pointer, _sel_shadowOpacity) + : _objc_msgSend_79(this.pointer, _sel_shadowOpacity); + } + + /// setShadowOpacity: + set shadowOpacity(double value) { + return _objc_msgSend_80(this.pointer, _sel_setShadowOpacity_, value); + } + + /// shadowOffset + void getShadowOffset(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_shadowOffset) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_shadowOffset); + } + + /// setShadowOffset: + set shadowOffset(CGSize value) { + return _objc_msgSend_92(this.pointer, _sel_setShadowOffset_, value); + } + + /// shadowRadius + double get shadowRadius { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_shadowRadius) + : _objc_msgSend_11(this.pointer, _sel_shadowRadius); + } + + /// setShadowRadius: + set shadowRadius(double value) { + return _objc_msgSend_26(this.pointer, _sel_setShadowRadius_, value); + } + + /// shadowPath + ffi.Pointer get shadowPath { + return _objc_msgSend_93(this.pointer, _sel_shadowPath); + } + + /// setShadowPath: + set shadowPath(ffi.Pointer value) { + return _objc_msgSend_94(this.pointer, _sel_setShadowPath_, value); + } + + /// preferredFrameSize + void preferredFrameSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_preferredFrameSize) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_preferredFrameSize); + } + + /// setNeedsLayout + void setNeedsLayout() { + _objc_msgSend_4(this.pointer, _sel_setNeedsLayout); + } + + /// needsLayout + bool needsLayout() { + return _objc_msgSend_5(this.pointer, _sel_needsLayout); + } + + /// layoutIfNeeded + void layoutIfNeeded() { + _objc_msgSend_4(this.pointer, _sel_layoutIfNeeded); + } + + /// layoutSublayers + void layoutSublayers() { + _objc_msgSend_4(this.pointer, _sel_layoutSublayers); + } + + /// defaultActionForKey: + static objc.ObjCObjectBase? defaultActionForKey_(objc.NSString event) { + final _ret = _objc_msgSend_57( + _class_CALayer, _sel_defaultActionForKey_, event.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// actionForKey: + objc.ObjCObjectBase? actionForKey_(objc.NSString event) { + final _ret = + _objc_msgSend_57(this.pointer, _sel_actionForKey_, event.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// actions + objc.ObjCObjectBase? get actions { + final _ret = _objc_msgSend_2(this.pointer, _sel_actions); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setActions: + set actions(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setActions_, value?.pointer ?? ffi.nullptr); + } + + /// addAnimation:forKey: + void addAnimation_forKey_(CAAnimation anim, objc.NSString? key) { + _objc_msgSend_100(this.pointer, _sel_addAnimation_forKey_, anim.pointer, + key?.pointer ?? ffi.nullptr); + } + + /// removeAllAnimations + void removeAllAnimations() { + _objc_msgSend_4(this.pointer, _sel_removeAllAnimations); + } + + /// removeAnimationForKey: + void removeAnimationForKey_(objc.NSString key) { + _objc_msgSend_101(this.pointer, _sel_removeAnimationForKey_, key.pointer); + } + + /// animationKeys + objc.NSArray? animationKeys() { + final _ret = _objc_msgSend_90(this.pointer, _sel_animationKeys); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// animationForKey: + CAAnimation? animationForKey_(objc.NSString key) { + final _ret = + _objc_msgSend_102(this.pointer, _sel_animationForKey_, key.pointer); + return _ret.address == 0 + ? null + : CAAnimation.castFromPointer(_ret, retain: true, release: true); + } + + /// name + objc.NSString? get name { + final _ret = _objc_msgSend_29(this.pointer, _sel_name); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setName: + set name(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setName_, value?.pointer ?? ffi.nullptr); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// style + objc.NSDictionary? get style { + final _ret = _objc_msgSend_104(this.pointer, _sel_style); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// setStyle: + set style(objc.NSDictionary? value) { + return _objc_msgSend_105( + this.pointer, _sel_setStyle_, value?.pointer ?? ffi.nullptr); + } + + /// new + static CALayer new1() { + final _ret = _objc_msgSend_18(_class_CALayer, _sel_new); + return CALayer.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static CALayer allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_CALayer, _sel_allocWithZone_, zone); + return CALayer.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static CALayer alloc() { + final _ret = _objc_msgSend_18(_class_CALayer, _sel_alloc); + return CALayer.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_CALayer = objc.getClass("CALayer"); +late final _sel_layer = objc.registerName("layer"); +late final _sel_initWithLayer_ = objc.registerName("initWithLayer:"); +final _objc_msgSend_56 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_presentationLayer = objc.registerName("presentationLayer"); +late final _sel_modelLayer = objc.registerName("modelLayer"); +late final _sel_defaultValueForKey_ = objc.registerName("defaultValueForKey:"); +final _objc_msgSend_57 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_needsDisplayForKey_ = objc.registerName("needsDisplayForKey:"); +final _objc_msgSend_58 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_shouldArchiveValueForKey_ = + objc.registerName("shouldArchiveValueForKey:"); +late final _sel_setBounds_ = objc.registerName("setBounds:"); +final _objc_msgSend_59 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_position = objc.registerName("position"); +final _objc_msgSend_60 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGPoint Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGPoint Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_60Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); +late final _sel_setPosition_ = objc.registerName("setPosition:"); +final _objc_msgSend_61 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGPoint)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGPoint)>(); +late final _sel_zPosition = objc.registerName("zPosition"); +late final _sel_setZPosition_ = objc.registerName("setZPosition:"); +late final _sel_anchorPoint = objc.registerName("anchorPoint"); +late final _sel_setAnchorPoint_ = objc.registerName("setAnchorPoint:"); +late final _sel_anchorPointZ = objc.registerName("anchorPointZ"); +late final _sel_setAnchorPointZ_ = objc.registerName("setAnchorPointZ:"); + +final class CATransform3D extends ffi.Struct { + @ffi.Double() + external double m11; + + @ffi.Double() + external double m12; + + @ffi.Double() + external double m13; + + @ffi.Double() + external double m14; + + @ffi.Double() + external double m21; + + @ffi.Double() + external double m22; + + @ffi.Double() + external double m23; + + @ffi.Double() + external double m24; + + @ffi.Double() + external double m31; + + @ffi.Double() + external double m32; + + @ffi.Double() + external double m33; + + @ffi.Double() + external double m34; + + @ffi.Double() + external double m41; + + @ffi.Double() + external double m42; + + @ffi.Double() + external double m43; + + @ffi.Double() + external double m44; +} + +late final _sel_transform = objc.registerName("transform"); +final _objc_msgSend_62 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CATransform3D Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CATransform3D Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_62Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); +late final _sel_setTransform_ = objc.registerName("setTransform:"); +final _objc_msgSend_63 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CATransform3D)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CATransform3D)>(); + +final class CGAffineTransform extends ffi.Struct { + @ffi.Double() + external double a; + + @ffi.Double() + external double b; + + @ffi.Double() + external double c; + + @ffi.Double() + external double d; + + @ffi.Double() + external double tx; + + @ffi.Double() + external double ty; +} + +late final _sel_affineTransform = objc.registerName("affineTransform"); +final _objc_msgSend_64 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGAffineTransform Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGAffineTransform Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_64Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAffineTransform_ = objc.registerName("setAffineTransform:"); +final _objc_msgSend_65 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform)>(); +late final _sel_frame = objc.registerName("frame"); +late final _sel_setFrame_ = objc.registerName("setFrame:"); +late final _sel_isHidden = objc.registerName("isHidden"); +late final _sel_setHidden_ = objc.registerName("setHidden:"); +late final _sel_isDoubleSided = objc.registerName("isDoubleSided"); +late final _sel_setDoubleSided_ = objc.registerName("setDoubleSided:"); +late final _sel_isGeometryFlipped = objc.registerName("isGeometryFlipped"); +late final _sel_setGeometryFlipped_ = objc.registerName("setGeometryFlipped:"); +late final _sel_contentsAreFlipped = objc.registerName("contentsAreFlipped"); +late final _sel_superlayer = objc.registerName("superlayer"); +final _objc_msgSend_66 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_removeFromSuperlayer = + objc.registerName("removeFromSuperlayer"); +late final _sel_sublayers = objc.registerName("sublayers"); +late final _sel_setSublayers_ = objc.registerName("setSublayers:"); +late final _sel_addSublayer_ = objc.registerName("addSublayer:"); +final _objc_msgSend_67 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_insertSublayer_atIndex_ = + objc.registerName("insertSublayer:atIndex:"); +final _objc_msgSend_68 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedInt)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_insertSublayer_below_ = + objc.registerName("insertSublayer:below:"); +final _objc_msgSend_69 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_insertSublayer_above_ = + objc.registerName("insertSublayer:above:"); +late final _sel_replaceSublayer_with_ = + objc.registerName("replaceSublayer:with:"); +final _objc_msgSend_70 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_sublayerTransform = objc.registerName("sublayerTransform"); +late final _sel_setSublayerTransform_ = + objc.registerName("setSublayerTransform:"); +late final _sel_mask = objc.registerName("mask"); +late final _sel_setMask_ = objc.registerName("setMask:"); +final _objc_msgSend_71 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_masksToBounds = objc.registerName("masksToBounds"); +late final _sel_setMasksToBounds_ = objc.registerName("setMasksToBounds:"); +late final _sel_convertPoint_fromLayer_ = + objc.registerName("convertPoint:fromLayer:"); +final _objc_msgSend_72 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>>() + .asFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>(); +final _objc_msgSend_72Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>(); +late final _sel_convertPoint_toLayer_ = + objc.registerName("convertPoint:toLayer:"); +late final _sel_convertRect_fromLayer_ = + objc.registerName("convertRect:fromLayer:"); +final _objc_msgSend_73 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +final _objc_msgSend_73Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +late final _sel_convertRect_toLayer_ = + objc.registerName("convertRect:toLayer:"); +late final _sel_convertTime_fromLayer_ = + objc.registerName("convertTime:fromLayer:"); +final _objc_msgSend_74 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer)>(); +final _objc_msgSend_74Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer)>(); +late final _sel_convertTime_toLayer_ = + objc.registerName("convertTime:toLayer:"); +late final _sel_hitTest_ = objc.registerName("hitTest:"); +final _objc_msgSend_75 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGPoint)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGPoint)>(); +late final _sel_containsPoint_ = objc.registerName("containsPoint:"); +final _objc_msgSend_76 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer, CGPoint)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, CGPoint)>(); +late final _sel_contents = objc.registerName("contents"); +late final _sel_setContents_ = objc.registerName("setContents:"); +late final _sel_contentsRect = objc.registerName("contentsRect"); +late final _sel_setContentsRect_ = objc.registerName("setContentsRect:"); +late final _sel_contentsGravity = objc.registerName("contentsGravity"); +final _objc_msgSend_77 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setContentsGravity_ = objc.registerName("setContentsGravity:"); +final _objc_msgSend_78 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_contentsScale = objc.registerName("contentsScale"); +late final _sel_setContentsScale_ = objc.registerName("setContentsScale:"); +late final _sel_contentsCenter = objc.registerName("contentsCenter"); +late final _sel_setContentsCenter_ = objc.registerName("setContentsCenter:"); +late final _sel_contentsFormat = objc.registerName("contentsFormat"); +late final _sel_setContentsFormat_ = objc.registerName("setContentsFormat:"); +late final _sel_wantsExtendedDynamicRangeContent = + objc.registerName("wantsExtendedDynamicRangeContent"); +late final _sel_setWantsExtendedDynamicRangeContent_ = + objc.registerName("setWantsExtendedDynamicRangeContent:"); +late final _sel_minificationFilter = objc.registerName("minificationFilter"); +late final _sel_setMinificationFilter_ = + objc.registerName("setMinificationFilter:"); +late final _sel_magnificationFilter = objc.registerName("magnificationFilter"); +late final _sel_setMagnificationFilter_ = + objc.registerName("setMagnificationFilter:"); +late final _sel_minificationFilterBias = + objc.registerName("minificationFilterBias"); +final _objc_msgSend_79 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Float Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_79Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Float Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setMinificationFilterBias_ = + objc.registerName("setMinificationFilterBias:"); +final _objc_msgSend_80 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Float)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_isOpaque = objc.registerName("isOpaque"); +late final _sel_setOpaque_ = objc.registerName("setOpaque:"); +late final _sel_display = objc.registerName("display"); +late final _sel_setNeedsDisplay = objc.registerName("setNeedsDisplay"); +late final _sel_setNeedsDisplayInRect_ = + objc.registerName("setNeedsDisplayInRect:"); +final _objc_msgSend_81 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_needsDisplay = objc.registerName("needsDisplay"); +late final _sel_displayIfNeeded = objc.registerName("displayIfNeeded"); +late final _sel_needsDisplayOnBoundsChange = + objc.registerName("needsDisplayOnBoundsChange"); +late final _sel_setNeedsDisplayOnBoundsChange_ = + objc.registerName("setNeedsDisplayOnBoundsChange:"); +late final _sel_drawsAsynchronously = objc.registerName("drawsAsynchronously"); +late final _sel_setDrawsAsynchronously_ = + objc.registerName("setDrawsAsynchronously:"); + +final class CGContext extends ffi.Opaque {} + +late final _sel_drawInContext_ = objc.registerName("drawInContext:"); +final _objc_msgSend_82 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_renderInContext_ = objc.registerName("renderInContext:"); + +enum CAEdgeAntialiasingMask { + kCALayerLeftEdge(1), + kCALayerRightEdge(2), + kCALayerBottomEdge(4), + kCALayerTopEdge(8); + + final int value; + const CAEdgeAntialiasingMask(this.value); + + static CAEdgeAntialiasingMask fromValue(int value) => switch (value) { + 1 => kCALayerLeftEdge, + 2 => kCALayerRightEdge, + 4 => kCALayerBottomEdge, + 8 => kCALayerTopEdge, + _ => throw ArgumentError( + "Unknown value for CAEdgeAntialiasingMask: $value"), + }; +} + +late final _sel_edgeAntialiasingMask = + objc.registerName("edgeAntialiasingMask"); +final _objc_msgSend_83 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedInt Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setEdgeAntialiasingMask_ = + objc.registerName("setEdgeAntialiasingMask:"); +final _objc_msgSend_84 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedInt)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_allowsEdgeAntialiasing = + objc.registerName("allowsEdgeAntialiasing"); +late final _sel_setAllowsEdgeAntialiasing_ = + objc.registerName("setAllowsEdgeAntialiasing:"); + +final class CGColor extends ffi.Opaque {} + +late final _sel_backgroundColor = objc.registerName("backgroundColor"); +final _objc_msgSend_85 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setBackgroundColor_ = objc.registerName("setBackgroundColor:"); +final _objc_msgSend_86 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_cornerRadius = objc.registerName("cornerRadius"); +late final _sel_setCornerRadius_ = objc.registerName("setCornerRadius:"); + +enum CACornerMask { + kCALayerMinXMinYCorner(1), + kCALayerMaxXMinYCorner(2), + kCALayerMinXMaxYCorner(4), + kCALayerMaxXMaxYCorner(8); + + final int value; + const CACornerMask(this.value); + + static CACornerMask fromValue(int value) => switch (value) { + 1 => kCALayerMinXMinYCorner, + 2 => kCALayerMaxXMinYCorner, + 4 => kCALayerMinXMaxYCorner, + 8 => kCALayerMaxXMaxYCorner, + _ => throw ArgumentError("Unknown value for CACornerMask: $value"), + }; +} + +late final _sel_maskedCorners = objc.registerName("maskedCorners"); +final _objc_msgSend_87 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setMaskedCorners_ = objc.registerName("setMaskedCorners:"); +final _objc_msgSend_88 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_cornerCurve = objc.registerName("cornerCurve"); +late final _sel_setCornerCurve_ = objc.registerName("setCornerCurve:"); +late final _sel_cornerCurveExpansionFactor_ = + objc.registerName("cornerCurveExpansionFactor:"); +final _objc_msgSend_89 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_89Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_borderWidth = objc.registerName("borderWidth"); +late final _sel_setBorderWidth_ = objc.registerName("setBorderWidth:"); +late final _sel_borderColor = objc.registerName("borderColor"); +late final _sel_setBorderColor_ = objc.registerName("setBorderColor:"); +late final _sel_opacity = objc.registerName("opacity"); +late final _sel_setOpacity_ = objc.registerName("setOpacity:"); +late final _sel_allowsGroupOpacity = objc.registerName("allowsGroupOpacity"); +late final _sel_setAllowsGroupOpacity_ = + objc.registerName("setAllowsGroupOpacity:"); +late final _sel_compositingFilter = objc.registerName("compositingFilter"); +late final _sel_setCompositingFilter_ = + objc.registerName("setCompositingFilter:"); +late final _sel_filters = objc.registerName("filters"); +final _objc_msgSend_90 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setFilters_ = objc.registerName("setFilters:"); +final _objc_msgSend_91 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_backgroundFilters = objc.registerName("backgroundFilters"); +late final _sel_setBackgroundFilters_ = + objc.registerName("setBackgroundFilters:"); +late final _sel_shouldRasterize = objc.registerName("shouldRasterize"); +late final _sel_setShouldRasterize_ = objc.registerName("setShouldRasterize:"); +late final _sel_rasterizationScale = objc.registerName("rasterizationScale"); +late final _sel_setRasterizationScale_ = + objc.registerName("setRasterizationScale:"); +late final _sel_shadowColor = objc.registerName("shadowColor"); +late final _sel_setShadowColor_ = objc.registerName("setShadowColor:"); +late final _sel_shadowOpacity = objc.registerName("shadowOpacity"); +late final _sel_setShadowOpacity_ = objc.registerName("setShadowOpacity:"); +late final _sel_shadowOffset = objc.registerName("shadowOffset"); +late final _sel_setShadowOffset_ = objc.registerName("setShadowOffset:"); +final _objc_msgSend_92 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGSize)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGSize)>(); +late final _sel_shadowRadius = objc.registerName("shadowRadius"); +late final _sel_setShadowRadius_ = objc.registerName("setShadowRadius:"); + +final class CGPath extends ffi.Opaque {} + +late final _sel_shadowPath = objc.registerName("shadowPath"); +final _objc_msgSend_93 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setShadowPath_ = objc.registerName("setShadowPath:"); +final _objc_msgSend_94 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_preferredFrameSize = objc.registerName("preferredFrameSize"); +late final _sel_setNeedsLayout = objc.registerName("setNeedsLayout"); +late final _sel_needsLayout = objc.registerName("needsLayout"); +late final _sel_layoutIfNeeded = objc.registerName("layoutIfNeeded"); +late final _sel_layoutSublayers = objc.registerName("layoutSublayers"); +late final _sel_defaultActionForKey_ = + objc.registerName("defaultActionForKey:"); +late final _sel_actionForKey_ = objc.registerName("actionForKey:"); +late final _sel_actions = objc.registerName("actions"); +late final _sel_setActions_ = objc.registerName("setActions:"); + +/// CAAnimation +class CAAnimation extends objc.NSObject { + CAAnimation._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [CAAnimation] that points to the same underlying object as [other]. + CAAnimation.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CAAnimation] that wraps the given raw object pointer. + CAAnimation.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CAAnimation]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_CAAnimation); + } + + /// animation + static CAAnimation animation() { + final _ret = _objc_msgSend_18(_class_CAAnimation, _sel_animation); + return CAAnimation.castFromPointer(_ret, retain: true, release: true); + } + + /// defaultValueForKey: + static objc.ObjCObjectBase? defaultValueForKey_(objc.NSString key) { + final _ret = _objc_msgSend_57( + _class_CAAnimation, _sel_defaultValueForKey_, key.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// shouldArchiveValueForKey: + bool shouldArchiveValueForKey_(objc.NSString key) { + return _objc_msgSend_58( + this.pointer, _sel_shouldArchiveValueForKey_, key.pointer); + } + + /// timingFunction + CAMediaTimingFunction? get timingFunction { + final _ret = _objc_msgSend_98(this.pointer, _sel_timingFunction); + return _ret.address == 0 + ? null + : CAMediaTimingFunction.castFromPointer(_ret, + retain: true, release: true); + } + + /// setTimingFunction: + set timingFunction(CAMediaTimingFunction? value) { + return _objc_msgSend_99( + this.pointer, _sel_setTimingFunction_, value?.pointer ?? ffi.nullptr); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// isRemovedOnCompletion + bool get removedOnCompletion { + return _objc_msgSend_5(this.pointer, _sel_isRemovedOnCompletion); + } + + /// setRemovedOnCompletion: + set removedOnCompletion(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setRemovedOnCompletion_, value); + } + + /// preferredFrameRateRange + void getPreferredFrameRateRange(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_50Stret( + stret, this.pointer, _sel_preferredFrameRateRange) + : stret.ref = + _objc_msgSend_50(this.pointer, _sel_preferredFrameRateRange); + } + + /// setPreferredFrameRateRange: + set preferredFrameRateRange(CAFrameRateRange value) { + return _objc_msgSend_51( + this.pointer, _sel_setPreferredFrameRateRange_, value); + } + + /// init + CAAnimation init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return CAAnimation.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static CAAnimation new1() { + final _ret = _objc_msgSend_18(_class_CAAnimation, _sel_new); + return CAAnimation.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static CAAnimation allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_CAAnimation, _sel_allocWithZone_, zone); + return CAAnimation.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static CAAnimation alloc() { + final _ret = _objc_msgSend_18(_class_CAAnimation, _sel_alloc); + return CAAnimation.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_CAAnimation = objc.getClass("CAAnimation"); +late final _sel_animation = objc.registerName("animation"); + +/// CAMediaTimingFunction +class CAMediaTimingFunction extends objc.NSObject { + CAMediaTimingFunction._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [CAMediaTimingFunction] that points to the same underlying object as [other]. + CAMediaTimingFunction.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CAMediaTimingFunction] that wraps the given raw object pointer. + CAMediaTimingFunction.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CAMediaTimingFunction]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_CAMediaTimingFunction); + } + + /// functionWithName: + static CAMediaTimingFunction functionWithName_(objc.NSString name) { + final _ret = _objc_msgSend_95( + _class_CAMediaTimingFunction, _sel_functionWithName_, name.pointer); + return CAMediaTimingFunction.castFromPointer(_ret, + retain: true, release: true); + } + + /// functionWithControlPoints:::: + static CAMediaTimingFunction functionWithControlPoints____( + double c1x, double c1y, double c2x, double c2y) { + final _ret = _objc_msgSend_96(_class_CAMediaTimingFunction, + _sel_functionWithControlPoints____, c1x, c1y, c2x, c2y); + return CAMediaTimingFunction.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithControlPoints:::: + CAMediaTimingFunction initWithControlPoints____( + double c1x, double c1y, double c2x, double c2y) { + final _ret = _objc_msgSend_96( + this.pointer, _sel_initWithControlPoints____, c1x, c1y, c2x, c2y); + return CAMediaTimingFunction.castFromPointer(_ret, + retain: true, release: true); + } + + /// getControlPointAtIndex:values: + void getControlPointAtIndex_values_(int idx, ffi.Pointer ptr) { + _objc_msgSend_97( + this.pointer, _sel_getControlPointAtIndex_values_, idx, ptr); + } + + /// init + CAMediaTimingFunction init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return CAMediaTimingFunction.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static CAMediaTimingFunction new1() { + final _ret = _objc_msgSend_18(_class_CAMediaTimingFunction, _sel_new); + return CAMediaTimingFunction.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static CAMediaTimingFunction allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_CAMediaTimingFunction, _sel_allocWithZone_, zone); + return CAMediaTimingFunction.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static CAMediaTimingFunction alloc() { + final _ret = _objc_msgSend_18(_class_CAMediaTimingFunction, _sel_alloc); + return CAMediaTimingFunction.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_CAMediaTimingFunction = + objc.getClass("CAMediaTimingFunction"); +late final _sel_functionWithName_ = objc.registerName("functionWithName:"); +final _objc_msgSend_95 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_functionWithControlPoints____ = + objc.registerName("functionWithControlPoints::::"); +final _objc_msgSend_96 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Float, + ffi.Float, + ffi.Float, + ffi.Float)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, double, double, double, double)>(); +late final _sel_initWithControlPoints____ = + objc.registerName("initWithControlPoints::::"); +late final _sel_getControlPointAtIndex_values_ = + objc.registerName("getControlPointAtIndex:values:"); +final _objc_msgSend_97 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Size, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int, ffi.Pointer)>(); +late final _sel_timingFunction = objc.registerName("timingFunction"); +final _objc_msgSend_98 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setTimingFunction_ = objc.registerName("setTimingFunction:"); +final _objc_msgSend_99 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isRemovedOnCompletion = + objc.registerName("isRemovedOnCompletion"); +late final _sel_setRemovedOnCompletion_ = + objc.registerName("setRemovedOnCompletion:"); +late final _sel_addAnimation_forKey_ = + objc.registerName("addAnimation:forKey:"); +final _objc_msgSend_100 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removeAllAnimations = objc.registerName("removeAllAnimations"); +late final _sel_removeAnimationForKey_ = + objc.registerName("removeAnimationForKey:"); +final _objc_msgSend_101 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_animationKeys = objc.registerName("animationKeys"); +late final _sel_animationForKey_ = objc.registerName("animationForKey:"); +final _objc_msgSend_102 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_name = objc.registerName("name"); +late final _sel_setName_ = objc.registerName("setName:"); +final _objc_msgSend_103 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_style = objc.registerName("style"); +final _objc_msgSend_104 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setStyle_ = objc.registerName("setStyle:"); +final _objc_msgSend_105 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_106 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_canBecomeFocused = objc.registerName("canBecomeFocused"); +late final _sel_isFocused = objc.registerName("isFocused"); +late final _sel_focusGroupIdentifier = + objc.registerName("focusGroupIdentifier"); +late final _sel_setFocusGroupIdentifier_ = + objc.registerName("setFocusGroupIdentifier:"); +late final _sel_focusGroupPriority = objc.registerName("focusGroupPriority"); +late final _sel_setFocusGroupPriority_ = + objc.registerName("setFocusGroupPriority:"); + +/// UIFocusEffect +class UIFocusEffect extends objc.NSObject { + UIFocusEffect._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIFocusEffect] that points to the same underlying object as [other]. + UIFocusEffect.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIFocusEffect] that wraps the given raw object pointer. + UIFocusEffect.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIFocusEffect]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIFocusEffect); + } + + /// effect + static UIFocusEffect effect() { + final _ret = _objc_msgSend_18(_class_UIFocusEffect, _sel_effect); + return UIFocusEffect.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIFocusEffect init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIFocusEffect.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIFocusEffect new1() { + final _ret = _objc_msgSend_18(_class_UIFocusEffect, _sel_new); + return UIFocusEffect.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIFocusEffect allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIFocusEffect, _sel_allocWithZone_, zone); + return UIFocusEffect.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIFocusEffect alloc() { + final _ret = _objc_msgSend_18(_class_UIFocusEffect, _sel_alloc); + return UIFocusEffect.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIFocusEffect = objc.getClass("UIFocusEffect"); +late final _sel_effect = objc.registerName("effect"); +late final _sel_focusEffect = objc.registerName("focusEffect"); +final _objc_msgSend_107 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setFocusEffect_ = objc.registerName("setFocusEffect:"); +final _objc_msgSend_108 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +enum UISemanticContentAttribute { + UISemanticContentAttributeUnspecified(0), + UISemanticContentAttributePlayback(1), + UISemanticContentAttributeSpatial(2), + UISemanticContentAttributeForceLeftToRight(3), + UISemanticContentAttributeForceRightToLeft(4); + + final int value; + const UISemanticContentAttribute(this.value); + + static UISemanticContentAttribute fromValue(int value) => switch (value) { + 0 => UISemanticContentAttributeUnspecified, + 1 => UISemanticContentAttributePlayback, + 2 => UISemanticContentAttributeSpatial, + 3 => UISemanticContentAttributeForceLeftToRight, + 4 => UISemanticContentAttributeForceRightToLeft, + _ => throw ArgumentError( + "Unknown value for UISemanticContentAttribute: $value"), + }; +} + +late final _sel_semanticContentAttribute = + objc.registerName("semanticContentAttribute"); +final _objc_msgSend_109 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setSemanticContentAttribute_ = + objc.registerName("setSemanticContentAttribute:"); +final _objc_msgSend_110 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +enum UIUserInterfaceLayoutDirection { + UIUserInterfaceLayoutDirectionLeftToRight(0), + UIUserInterfaceLayoutDirectionRightToLeft(1); + + final int value; + const UIUserInterfaceLayoutDirection(this.value); + + static UIUserInterfaceLayoutDirection fromValue(int value) => switch (value) { + 0 => UIUserInterfaceLayoutDirectionLeftToRight, + 1 => UIUserInterfaceLayoutDirectionRightToLeft, + _ => throw ArgumentError( + "Unknown value for UIUserInterfaceLayoutDirection: $value"), + }; +} + +late final _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_ = objc + .registerName("userInterfaceLayoutDirectionForSemanticContentAttribute:"); +final _objc_msgSend_111 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_ = + objc.registerName( + "userInterfaceLayoutDirectionForSemanticContentAttribute:relativeToLayoutDirection:"); +final _objc_msgSend_112 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.UnsignedLong)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, int, int)>(); +late final _sel_effectiveUserInterfaceLayoutDirection = + objc.registerName("effectiveUserInterfaceLayoutDirection"); +final _objc_msgSend_113 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UIResponder +class UIResponder extends objc.NSObject { + UIResponder._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIResponder] that points to the same underlying object as [other]. + UIResponder.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIResponder] that wraps the given raw object pointer. + UIResponder.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIResponder]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIResponder); + } + + /// nextResponder + UIResponder? get nextResponder { + final _ret = _objc_msgSend_114(this.pointer, _sel_nextResponder); + return _ret.address == 0 + ? null + : UIResponder.castFromPointer(_ret, retain: true, release: true); + } + + /// canBecomeFirstResponder + bool get canBecomeFirstResponder { + return _objc_msgSend_5(this.pointer, _sel_canBecomeFirstResponder); + } + + /// becomeFirstResponder + bool becomeFirstResponder() { + return _objc_msgSend_5(this.pointer, _sel_becomeFirstResponder); + } + + /// canResignFirstResponder + bool get canResignFirstResponder { + return _objc_msgSend_5(this.pointer, _sel_canResignFirstResponder); + } + + /// resignFirstResponder + bool resignFirstResponder() { + return _objc_msgSend_5(this.pointer, _sel_resignFirstResponder); + } + + /// isFirstResponder + bool get isFirstResponder { + return _objc_msgSend_5(this.pointer, _sel_isFirstResponder); + } + + /// touchesBegan:withEvent: + void touchesBegan_withEvent_(objc.ObjCObjectBase touches, UIEvent? event) { + _objc_msgSend_115(this.pointer, _sel_touchesBegan_withEvent_, + touches.pointer, event?.pointer ?? ffi.nullptr); + } + + /// touchesMoved:withEvent: + void touchesMoved_withEvent_(objc.NSSet touches, UIEvent? event) { + _objc_msgSend_116(this.pointer, _sel_touchesMoved_withEvent_, + touches.pointer, event?.pointer ?? ffi.nullptr); + } + + /// touchesEnded:withEvent: + void touchesEnded_withEvent_(objc.NSSet touches, UIEvent? event) { + _objc_msgSend_116(this.pointer, _sel_touchesEnded_withEvent_, + touches.pointer, event?.pointer ?? ffi.nullptr); + } + + /// touchesCancelled:withEvent: + void touchesCancelled_withEvent_(objc.NSSet touches, UIEvent? event) { + _objc_msgSend_116(this.pointer, _sel_touchesCancelled_withEvent_, + touches.pointer, event?.pointer ?? ffi.nullptr); + } + + /// touchesEstimatedPropertiesUpdated: + void touchesEstimatedPropertiesUpdated_(objc.NSSet touches) { + _objc_msgSend_117( + this.pointer, _sel_touchesEstimatedPropertiesUpdated_, touches.pointer); + } + + /// pressesBegan:withEvent: + void pressesBegan_withEvent_(objc.NSSet presses, UIPressesEvent? event) { + _objc_msgSend_129(this.pointer, _sel_pressesBegan_withEvent_, + presses.pointer, event?.pointer ?? ffi.nullptr); + } + + /// pressesChanged:withEvent: + void pressesChanged_withEvent_(objc.NSSet presses, UIPressesEvent? event) { + _objc_msgSend_129(this.pointer, _sel_pressesChanged_withEvent_, + presses.pointer, event?.pointer ?? ffi.nullptr); + } + + /// pressesEnded:withEvent: + void pressesEnded_withEvent_(objc.NSSet presses, UIPressesEvent? event) { + _objc_msgSend_129(this.pointer, _sel_pressesEnded_withEvent_, + presses.pointer, event?.pointer ?? ffi.nullptr); + } + + /// pressesCancelled:withEvent: + void pressesCancelled_withEvent_(objc.NSSet presses, UIPressesEvent? event) { + _objc_msgSend_129(this.pointer, _sel_pressesCancelled_withEvent_, + presses.pointer, event?.pointer ?? ffi.nullptr); + } + + /// motionBegan:withEvent: + void motionBegan_withEvent_(UIEventSubtype motion, UIEvent? event) { + _objc_msgSend_130(this.pointer, _sel_motionBegan_withEvent_, motion.value, + event?.pointer ?? ffi.nullptr); + } + + /// motionEnded:withEvent: + void motionEnded_withEvent_(UIEventSubtype motion, UIEvent? event) { + _objc_msgSend_130(this.pointer, _sel_motionEnded_withEvent_, motion.value, + event?.pointer ?? ffi.nullptr); + } + + /// motionCancelled:withEvent: + void motionCancelled_withEvent_(UIEventSubtype motion, UIEvent? event) { + _objc_msgSend_130(this.pointer, _sel_motionCancelled_withEvent_, + motion.value, event?.pointer ?? ffi.nullptr); + } + + /// remoteControlReceivedWithEvent: + void remoteControlReceivedWithEvent_(UIEvent? event) { + _objc_msgSend_131(this.pointer, _sel_remoteControlReceivedWithEvent_, + event?.pointer ?? ffi.nullptr); + } + + /// canPerformAction:withSender: + bool canPerformAction_withSender_( + ffi.Pointer action, objc.ObjCObjectBase? sender) { + return _objc_msgSend_132(this.pointer, _sel_canPerformAction_withSender_, + action, sender?.pointer ?? ffi.nullptr); + } + + /// targetForAction:withSender: + objc.ObjCObjectBase? targetForAction_withSender_( + ffi.Pointer action, objc.ObjCObjectBase? sender) { + final _ret = _objc_msgSend_133( + this.pointer, + _sel_targetForAction_withSender_, + action, + sender?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// buildMenuWithBuilder: + void buildMenuWithBuilder_(objc.ObjCObjectBase builder) { + _objc_msgSend_134( + this.pointer, _sel_buildMenuWithBuilder_, builder.pointer); + } + + /// validateCommand: + void validateCommand_(UICommand command) { + _objc_msgSend_368(this.pointer, _sel_validateCommand_, command.pointer); + } + + /// undoManager + NSUndoManager? get undoManager { + final _ret = _objc_msgSend_374(this.pointer, _sel_undoManager); + return _ret.address == 0 + ? null + : NSUndoManager.castFromPointer(_ret, retain: true, release: true); + } + + /// editingInteractionConfiguration + UIEditingInteractionConfiguration get editingInteractionConfiguration { + final _ret = + _objc_msgSend_375(this.pointer, _sel_editingInteractionConfiguration); + return UIEditingInteractionConfiguration.fromValue(_ret); + } + + /// init + UIResponder init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIResponder.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIResponder new1() { + final _ret = _objc_msgSend_18(_class_UIResponder, _sel_new); + return UIResponder.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIResponder allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIResponder, _sel_allocWithZone_, zone); + return UIResponder.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIResponder alloc() { + final _ret = _objc_msgSend_18(_class_UIResponder, _sel_alloc); + return UIResponder.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIResponder = objc.getClass("UIResponder"); +late final _sel_nextResponder = objc.registerName("nextResponder"); +final _objc_msgSend_114 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_canBecomeFirstResponder = + objc.registerName("canBecomeFirstResponder"); +late final _sel_becomeFirstResponder = + objc.registerName("becomeFirstResponder"); +late final _sel_canResignFirstResponder = + objc.registerName("canResignFirstResponder"); +late final _sel_resignFirstResponder = + objc.registerName("resignFirstResponder"); +late final _sel_isFirstResponder = objc.registerName("isFirstResponder"); +late final _sel_touchesBegan_withEvent_ = + objc.registerName("touchesBegan:withEvent:"); +final _objc_msgSend_115 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_touchesMoved_withEvent_ = + objc.registerName("touchesMoved:withEvent:"); +final _objc_msgSend_116 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_touchesEnded_withEvent_ = + objc.registerName("touchesEnded:withEvent:"); +late final _sel_touchesCancelled_withEvent_ = + objc.registerName("touchesCancelled:withEvent:"); +late final _sel_touchesEstimatedPropertiesUpdated_ = + objc.registerName("touchesEstimatedPropertiesUpdated:"); +final _objc_msgSend_117 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// UIPressesEvent +class UIPressesEvent extends UIEvent { + UIPressesEvent._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIPressesEvent] that points to the same underlying object as [other]. + UIPressesEvent.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIPressesEvent] that wraps the given raw object pointer. + UIPressesEvent.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIPressesEvent]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIPressesEvent); + } + + /// allPresses + objc.NSSet get allPresses { + final _ret = _objc_msgSend_118(this.pointer, _sel_allPresses); + return objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// pressesForGestureRecognizer: + objc.NSSet pressesForGestureRecognizer_(UIGestureRecognizer gesture) { + final _ret = _objc_msgSend_128( + this.pointer, _sel_pressesForGestureRecognizer_, gesture.pointer); + return objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } +} + +late final _class_UIPressesEvent = objc.getClass("UIPressesEvent"); +late final _sel_allPresses = objc.registerName("allPresses"); +final _objc_msgSend_118 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UIGestureRecognizer +class UIGestureRecognizer extends objc.NSObject { + UIGestureRecognizer._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIGestureRecognizer] that points to the same underlying object as [other]. + UIGestureRecognizer.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIGestureRecognizer] that wraps the given raw object pointer. + UIGestureRecognizer.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIGestureRecognizer]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIGestureRecognizer); + } + + /// initWithTarget:action: + UIGestureRecognizer initWithTarget_action_( + objc.ObjCObjectBase? target, ffi.Pointer action) { + final _ret = _objc_msgSend_119(this.pointer, _sel_initWithTarget_action_, + target?.pointer ?? ffi.nullptr, action); + return UIGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UIGestureRecognizer init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithCoder: + UIGestureRecognizer? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// addTarget:action: + void addTarget_action_( + objc.ObjCObjectBase target, ffi.Pointer action) { + _objc_msgSend_120( + this.pointer, _sel_addTarget_action_, target.pointer, action); + } + + /// removeTarget:action: + void removeTarget_action_( + objc.ObjCObjectBase? target, ffi.Pointer action) { + _objc_msgSend_121(this.pointer, _sel_removeTarget_action_, + target?.pointer ?? ffi.nullptr, action); + } + + /// state + UIGestureRecognizerState get state { + final _ret = _objc_msgSend_122(this.pointer, _sel_state); + return UIGestureRecognizerState.fromValue(_ret); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// isEnabled + bool get enabled { + return _objc_msgSend_5(this.pointer, _sel_isEnabled); + } + + /// setEnabled: + set enabled(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setEnabled_, value); + } + + /// view + UIView? get view { + final _ret = _objc_msgSend_123(this.pointer, _sel_view); + return _ret.address == 0 + ? null + : UIView.castFromPointer(_ret, retain: true, release: true); + } + + /// cancelsTouchesInView + bool get cancelsTouchesInView { + return _objc_msgSend_5(this.pointer, _sel_cancelsTouchesInView); + } + + /// setCancelsTouchesInView: + set cancelsTouchesInView(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setCancelsTouchesInView_, value); + } + + /// delaysTouchesBegan + bool get delaysTouchesBegan { + return _objc_msgSend_5(this.pointer, _sel_delaysTouchesBegan); + } + + /// setDelaysTouchesBegan: + set delaysTouchesBegan(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setDelaysTouchesBegan_, value); + } + + /// delaysTouchesEnded + bool get delaysTouchesEnded { + return _objc_msgSend_5(this.pointer, _sel_delaysTouchesEnded); + } + + /// setDelaysTouchesEnded: + set delaysTouchesEnded(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setDelaysTouchesEnded_, value); + } + + /// allowedTouchTypes + objc.NSArray get allowedTouchTypes { + final _ret = _objc_msgSend_14(this.pointer, _sel_allowedTouchTypes); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// setAllowedTouchTypes: + set allowedTouchTypes(objc.NSArray value) { + return _objc_msgSend_124( + this.pointer, _sel_setAllowedTouchTypes_, value.pointer); + } + + /// allowedPressTypes + objc.NSArray get allowedPressTypes { + final _ret = _objc_msgSend_14(this.pointer, _sel_allowedPressTypes); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// setAllowedPressTypes: + set allowedPressTypes(objc.NSArray value) { + return _objc_msgSend_124( + this.pointer, _sel_setAllowedPressTypes_, value.pointer); + } + + /// requiresExclusiveTouchType + bool get requiresExclusiveTouchType { + return _objc_msgSend_5(this.pointer, _sel_requiresExclusiveTouchType); + } + + /// setRequiresExclusiveTouchType: + set requiresExclusiveTouchType(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setRequiresExclusiveTouchType_, value); + } + + /// requireGestureRecognizerToFail: + void requireGestureRecognizerToFail_( + UIGestureRecognizer otherGestureRecognizer) { + _objc_msgSend_125(this.pointer, _sel_requireGestureRecognizerToFail_, + otherGestureRecognizer.pointer); + } + + /// locationInView: + void locationInView_(ffi.Pointer stret, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_126Stret(stret, this.pointer, _sel_locationInView_, + view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_126( + this.pointer, _sel_locationInView_, view?.pointer ?? ffi.nullptr); + } + + /// numberOfTouches + int get numberOfTouches { + return _objc_msgSend_42(this.pointer, _sel_numberOfTouches); + } + + /// locationOfTouch:inView: + void locationOfTouch_inView_( + ffi.Pointer stret, int touchIndex, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_127Stret( + stret, + this.pointer, + _sel_locationOfTouch_inView_, + touchIndex, + view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_127( + this.pointer, + _sel_locationOfTouch_inView_, + touchIndex, + view?.pointer ?? ffi.nullptr); + } + + /// name + objc.NSString? get name { + final _ret = _objc_msgSend_29(this.pointer, _sel_name); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setName: + set name(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setName_, value?.pointer ?? ffi.nullptr); + } + + /// modifierFlags + UIKeyModifierFlags get modifierFlags { + final _ret = _objc_msgSend_12(this.pointer, _sel_modifierFlags); + return UIKeyModifierFlags.fromValue(_ret); + } + + /// buttonMask + UIEventButtonMask get buttonMask { + final _ret = _objc_msgSend_13(this.pointer, _sel_buttonMask); + return UIEventButtonMask.fromValue(_ret); + } + + /// new + static UIGestureRecognizer new1() { + final _ret = _objc_msgSend_18(_class_UIGestureRecognizer, _sel_new); + return UIGestureRecognizer.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIGestureRecognizer allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIGestureRecognizer, _sel_allocWithZone_, zone); + return UIGestureRecognizer.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIGestureRecognizer alloc() { + final _ret = _objc_msgSend_18(_class_UIGestureRecognizer, _sel_alloc); + return UIGestureRecognizer.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIGestureRecognizer = objc.getClass("UIGestureRecognizer"); +late final _sel_initWithTarget_action_ = + objc.registerName("initWithTarget:action:"); +final _objc_msgSend_119 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_addTarget_action_ = objc.registerName("addTarget:action:"); +final _objc_msgSend_120 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removeTarget_action_ = + objc.registerName("removeTarget:action:"); +final _objc_msgSend_121 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +enum UIGestureRecognizerState { + UIGestureRecognizerStatePossible(0), + UIGestureRecognizerStateBegan(1), + UIGestureRecognizerStateChanged(2), + UIGestureRecognizerStateEnded(3), + UIGestureRecognizerStateCancelled(4), + UIGestureRecognizerStateFailed(5); + + static const UIGestureRecognizerStateRecognized = + UIGestureRecognizerStateEnded; + + final int value; + const UIGestureRecognizerState(this.value); + + static UIGestureRecognizerState fromValue(int value) => switch (value) { + 0 => UIGestureRecognizerStatePossible, + 1 => UIGestureRecognizerStateBegan, + 2 => UIGestureRecognizerStateChanged, + 3 => UIGestureRecognizerStateEnded, + 4 => UIGestureRecognizerStateCancelled, + 5 => UIGestureRecognizerStateFailed, + _ => throw ArgumentError( + "Unknown value for UIGestureRecognizerState: $value"), + }; + + @override + String toString() { + if (this == UIGestureRecognizerStateEnded) + return "UIGestureRecognizerState.UIGestureRecognizerStateEnded, UIGestureRecognizerState.UIGestureRecognizerStateRecognized"; + return super.toString(); + } +} + +late final _sel_state = objc.registerName("state"); +final _objc_msgSend_122 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isEnabled = objc.registerName("isEnabled"); +late final _sel_setEnabled_ = objc.registerName("setEnabled:"); +late final _sel_view = objc.registerName("view"); +final _objc_msgSend_123 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_cancelsTouchesInView = + objc.registerName("cancelsTouchesInView"); +late final _sel_setCancelsTouchesInView_ = + objc.registerName("setCancelsTouchesInView:"); +late final _sel_delaysTouchesBegan = objc.registerName("delaysTouchesBegan"); +late final _sel_setDelaysTouchesBegan_ = + objc.registerName("setDelaysTouchesBegan:"); +late final _sel_delaysTouchesEnded = objc.registerName("delaysTouchesEnded"); +late final _sel_setDelaysTouchesEnded_ = + objc.registerName("setDelaysTouchesEnded:"); +late final _sel_allowedTouchTypes = objc.registerName("allowedTouchTypes"); +late final _sel_setAllowedTouchTypes_ = + objc.registerName("setAllowedTouchTypes:"); +final _objc_msgSend_124 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_allowedPressTypes = objc.registerName("allowedPressTypes"); +late final _sel_setAllowedPressTypes_ = + objc.registerName("setAllowedPressTypes:"); +late final _sel_requiresExclusiveTouchType = + objc.registerName("requiresExclusiveTouchType"); +late final _sel_setRequiresExclusiveTouchType_ = + objc.registerName("setRequiresExclusiveTouchType:"); +late final _sel_requireGestureRecognizerToFail_ = + objc.registerName("requireGestureRecognizerToFail:"); +final _objc_msgSend_125 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_locationInView_ = objc.registerName("locationInView:"); +final _objc_msgSend_126 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGPoint Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_126Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_numberOfTouches = objc.registerName("numberOfTouches"); +late final _sel_locationOfTouch_inView_ = + objc.registerName("locationOfTouch:inView:"); +final _objc_msgSend_127 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +final _objc_msgSend_127Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_pressesForGestureRecognizer_ = + objc.registerName("pressesForGestureRecognizer:"); +final _objc_msgSend_128 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_pressesBegan_withEvent_ = + objc.registerName("pressesBegan:withEvent:"); +final _objc_msgSend_129 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pressesChanged_withEvent_ = + objc.registerName("pressesChanged:withEvent:"); +late final _sel_pressesEnded_withEvent_ = + objc.registerName("pressesEnded:withEvent:"); +late final _sel_pressesCancelled_withEvent_ = + objc.registerName("pressesCancelled:withEvent:"); +late final _sel_motionBegan_withEvent_ = + objc.registerName("motionBegan:withEvent:"); +final _objc_msgSend_130 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_motionEnded_withEvent_ = + objc.registerName("motionEnded:withEvent:"); +late final _sel_motionCancelled_withEvent_ = + objc.registerName("motionCancelled:withEvent:"); +late final _sel_remoteControlReceivedWithEvent_ = + objc.registerName("remoteControlReceivedWithEvent:"); +final _objc_msgSend_131 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_canPerformAction_withSender_ = + objc.registerName("canPerformAction:withSender:"); +final _objc_msgSend_132 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_targetForAction_withSender_ = + objc.registerName("targetForAction:withSender:"); +final _objc_msgSend_133 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_buildMenuWithBuilder_ = + objc.registerName("buildMenuWithBuilder:"); +final _objc_msgSend_134 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// UICommand +class UICommand extends UIMenuElement { + UICommand._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UICommand] that points to the same underlying object as [other]. + UICommand.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UICommand] that wraps the given raw object pointer. + UICommand.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UICommand]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UICommand); + } + + /// title + objc.NSString get title { + final _ret = _objc_msgSend_77(this.pointer, _sel_title); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTitle: + set title(objc.NSString value) { + return _objc_msgSend_78(this.pointer, _sel_setTitle_, value.pointer); + } + + /// image + UIImage? get image { + final _ret = _objc_msgSend_356(this.pointer, _sel_image); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// setImage: + set image(UIImage? value) { + return _objc_msgSend_360( + this.pointer, _sel_setImage_, value?.pointer ?? ffi.nullptr); + } + + /// discoverabilityTitle + objc.NSString? get discoverabilityTitle { + final _ret = _objc_msgSend_29(this.pointer, _sel_discoverabilityTitle); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setDiscoverabilityTitle: + set discoverabilityTitle(objc.NSString? value) { + return _objc_msgSend_103(this.pointer, _sel_setDiscoverabilityTitle_, + value?.pointer ?? ffi.nullptr); + } + + /// action + ffi.Pointer get action { + return _objc_msgSend_361(this.pointer, _sel_action); + } + + /// propertyList + objc.ObjCObjectBase? get propertyList { + final _ret = _objc_msgSend_2(this.pointer, _sel_propertyList); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// attributes + UIMenuElementAttributes get attributes { + final _ret = _objc_msgSend_362(this.pointer, _sel_attributes); + return UIMenuElementAttributes.fromValue(_ret); + } + + /// setAttributes: + set attributes(UIMenuElementAttributes value) { + return _objc_msgSend_363(this.pointer, _sel_setAttributes_, value.value); + } + + /// state + UIMenuElementState get state { + final _ret = _objc_msgSend_364(this.pointer, _sel_state); + return UIMenuElementState.fromValue(_ret); + } + + /// setState: + set state(UIMenuElementState value) { + return _objc_msgSend_365(this.pointer, _sel_setState_, value.value); + } + + /// alternates + objc.NSArray get alternates { + final _ret = _objc_msgSend_14(this.pointer, _sel_alternates); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// commandWithTitle:image:action:propertyList: + static UICommand commandWithTitle_image_action_propertyList_( + objc.NSString title, + UIImage? image, + ffi.Pointer action, + objc.ObjCObjectBase? propertyList) { + final _ret = _objc_msgSend_366( + _class_UICommand, + _sel_commandWithTitle_image_action_propertyList_, + title.pointer, + image?.pointer ?? ffi.nullptr, + action, + propertyList?.pointer ?? ffi.nullptr); + return UICommand.castFromPointer(_ret, retain: true, release: true); + } + + /// commandWithTitle:image:action:propertyList:alternates: + static UICommand commandWithTitle_image_action_propertyList_alternates_( + objc.NSString title, + UIImage? image, + ffi.Pointer action, + objc.ObjCObjectBase? propertyList, + objc.NSArray alternates) { + final _ret = _objc_msgSend_367( + _class_UICommand, + _sel_commandWithTitle_image_action_propertyList_alternates_, + title.pointer, + image?.pointer ?? ffi.nullptr, + action, + propertyList?.pointer ?? ffi.nullptr, + alternates.pointer); + return UICommand.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UICommand new1() { + final _ret = _objc_msgSend_18(_class_UICommand, _sel_new); + return UICommand.castFromPointer(_ret, retain: false, release: true); + } + + /// init + UICommand init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UICommand.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UICommand? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UICommand.castFromPointer(_ret, retain: true, release: true); + } + + /// allocWithZone: + static UICommand allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UICommand, _sel_allocWithZone_, zone); + return UICommand.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UICommand alloc() { + final _ret = _objc_msgSend_18(_class_UICommand, _sel_alloc); + return UICommand.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UICommand = objc.getClass("UICommand"); +late final _sel_title = objc.registerName("title"); +late final _sel_setTitle_ = objc.registerName("setTitle:"); + +/// UIImage +class UIImage extends objc.NSObject { + UIImage._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIImage] that points to the same underlying object as [other]. + UIImage.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIImage] that wraps the given raw object pointer. + UIImage.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIImage]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIImage); + } + + /// systemImageNamed: + static UIImage? systemImageNamed_(objc.NSString name) { + final _ret = + _objc_msgSend_135(_class_UIImage, _sel_systemImageNamed_, name.pointer); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// systemImageNamed:withConfiguration: + static UIImage? systemImageNamed_withConfiguration_( + objc.NSString name, UIImageConfiguration? configuration) { + final _ret = _objc_msgSend_171( + _class_UIImage, + _sel_systemImageNamed_withConfiguration_, + name.pointer, + configuration?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// systemImageNamed:compatibleWithTraitCollection: + static UIImage? systemImageNamed_compatibleWithTraitCollection_( + objc.NSString name, UITraitCollection? traitCollection) { + final _ret = _objc_msgSend_172( + _class_UIImage, + _sel_systemImageNamed_compatibleWithTraitCollection_, + name.pointer, + traitCollection?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// systemImageNamed:variableValue:withConfiguration: + static UIImage? systemImageNamed_variableValue_withConfiguration_( + objc.NSString name, double value, UIImageConfiguration? configuration) { + final _ret = _objc_msgSend_173( + _class_UIImage, + _sel_systemImageNamed_variableValue_withConfiguration_, + name.pointer, + value, + configuration?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageNamed: + static UIImage? imageNamed_(objc.NSString name) { + final _ret = + _objc_msgSend_135(_class_UIImage, _sel_imageNamed_, name.pointer); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageNamed:inBundle:withConfiguration: + static UIImage? imageNamed_inBundle_withConfiguration_(objc.NSString name, + NSBundle? bundle, UIImageConfiguration? configuration) { + final _ret = _objc_msgSend_200( + _class_UIImage, + _sel_imageNamed_inBundle_withConfiguration_, + name.pointer, + bundle?.pointer ?? ffi.nullptr, + configuration?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageNamed:inBundle:compatibleWithTraitCollection: + static UIImage? imageNamed_inBundle_compatibleWithTraitCollection_( + objc.NSString name, + NSBundle? bundle, + UITraitCollection? traitCollection) { + final _ret = _objc_msgSend_201( + _class_UIImage, + _sel_imageNamed_inBundle_compatibleWithTraitCollection_, + name.pointer, + bundle?.pointer ?? ffi.nullptr, + traitCollection?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageNamed:inBundle:variableValue:withConfiguration: + static UIImage? imageNamed_inBundle_variableValue_withConfiguration_( + objc.NSString name, + NSBundle? bundle, + double value, + UIImageConfiguration? configuration) { + final _ret = _objc_msgSend_202( + _class_UIImage, + _sel_imageNamed_inBundle_variableValue_withConfiguration_, + name.pointer, + bundle?.pointer ?? ffi.nullptr, + value, + configuration?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithContentsOfFile: + static UIImage? imageWithContentsOfFile_(objc.NSString path) { + final _ret = _objc_msgSend_135( + _class_UIImage, _sel_imageWithContentsOfFile_, path.pointer); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithData: + static UIImage? imageWithData_(objc.NSData data) { + final _ret = + _objc_msgSend_203(_class_UIImage, _sel_imageWithData_, data.pointer); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithData:scale: + static UIImage? imageWithData_scale_(objc.NSData data, double scale) { + final _ret = _objc_msgSend_204( + _class_UIImage, _sel_imageWithData_scale_, data.pointer, scale); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCGImage: + static UIImage imageWithCGImage_(ffi.Pointer cgImage) { + final _ret = + _objc_msgSend_205(_class_UIImage, _sel_imageWithCGImage_, cgImage); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCGImage:scale:orientation: + static UIImage imageWithCGImage_scale_orientation_( + ffi.Pointer cgImage, + double scale, + UIImageOrientation orientation) { + final _ret = _objc_msgSend_206( + _class_UIImage, + _sel_imageWithCGImage_scale_orientation_, + cgImage, + scale, + orientation.value); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCIImage: + static UIImage imageWithCIImage_(CIImage ciImage) { + final _ret = _objc_msgSend_275( + _class_UIImage, _sel_imageWithCIImage_, ciImage.pointer); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCIImage:scale:orientation: + static UIImage imageWithCIImage_scale_orientation_( + CIImage ciImage, double scale, UIImageOrientation orientation) { + final _ret = _objc_msgSend_276( + _class_UIImage, + _sel_imageWithCIImage_scale_orientation_, + ciImage.pointer, + scale, + orientation.value); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithContentsOfFile: + UIImage? initWithContentsOfFile_(objc.NSString path) { + final _ret = _objc_msgSend_57( + this.pointer, _sel_initWithContentsOfFile_, path.pointer); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithData: + UIImage? initWithData_(objc.NSData data) { + final _ret = + _objc_msgSend_240(this.pointer, _sel_initWithData_, data.pointer); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithData:scale: + UIImage? initWithData_scale_(objc.NSData data, double scale) { + final _ret = _objc_msgSend_277( + this.pointer, _sel_initWithData_scale_, data.pointer, scale); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCGImage: + UIImage initWithCGImage_(ffi.Pointer cgImage) { + final _ret = + _objc_msgSend_235(this.pointer, _sel_initWithCGImage_, cgImage); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCGImage:scale:orientation: + UIImage initWithCGImage_scale_orientation_(ffi.Pointer cgImage, + double scale, UIImageOrientation orientation) { + final _ret = _objc_msgSend_278( + this.pointer, + _sel_initWithCGImage_scale_orientation_, + cgImage, + scale, + orientation.value); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCIImage: + UIImage initWithCIImage_(CIImage ciImage) { + final _ret = + _objc_msgSend_279(this.pointer, _sel_initWithCIImage_, ciImage.pointer); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCIImage:scale:orientation: + UIImage initWithCIImage_scale_orientation_( + CIImage ciImage, double scale, UIImageOrientation orientation) { + final _ret = _objc_msgSend_280( + this.pointer, + _sel_initWithCIImage_scale_orientation_, + ciImage.pointer, + scale, + orientation.value); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// size + void getSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_size) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_size); + } + + /// CGImage + ffi.Pointer get CGImage1 { + return _objc_msgSend_273(this.pointer, _sel_CGImage); + } + + /// CIImage + CIImage? get CIImage1 { + final _ret = _objc_msgSend_281(this.pointer, _sel_CIImage); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageOrientation + UIImageOrientation get imageOrientation { + final _ret = _objc_msgSend_282(this.pointer, _sel_imageOrientation); + return UIImageOrientation.fromValue(_ret); + } + + /// scale + double get scale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_scale) + : _objc_msgSend_11(this.pointer, _sel_scale); + } + + /// isSymbolImage + bool get symbolImage { + return _objc_msgSend_5(this.pointer, _sel_isSymbolImage); + } + + /// animatedImageNamed:duration: + static UIImage? animatedImageNamed_duration_( + objc.NSString name, double duration) { + final _ret = _objc_msgSend_283(_class_UIImage, + _sel_animatedImageNamed_duration_, name.pointer, duration); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// animatedResizableImageNamed:capInsets:duration: + static UIImage? animatedResizableImageNamed_capInsets_duration_( + objc.NSString name, UIEdgeInsets capInsets, double duration) { + final _ret = _objc_msgSend_284( + _class_UIImage, + _sel_animatedResizableImageNamed_capInsets_duration_, + name.pointer, + capInsets, + duration); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// animatedResizableImageNamed:capInsets:resizingMode:duration: + static UIImage? animatedResizableImageNamed_capInsets_resizingMode_duration_( + objc.NSString name, + UIEdgeInsets capInsets, + UIImageResizingMode resizingMode, + double duration) { + final _ret = _objc_msgSend_285( + _class_UIImage, + _sel_animatedResizableImageNamed_capInsets_resizingMode_duration_, + name.pointer, + capInsets, + resizingMode.value, + duration); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// animatedImageWithImages:duration: + static UIImage? animatedImageWithImages_duration_( + objc.NSArray images, double duration) { + final _ret = _objc_msgSend_286(_class_UIImage, + _sel_animatedImageWithImages_duration_, images.pointer, duration); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// images + objc.NSArray? get images { + final _ret = _objc_msgSend_90(this.pointer, _sel_images); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// duration + double get duration { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_duration) + : _objc_msgSend_11(this.pointer, _sel_duration); + } + + /// drawAtPoint: + void drawAtPoint_(CGPoint point) { + _objc_msgSend_287(this.pointer, _sel_drawAtPoint_, point); + } + + /// drawAtPoint:blendMode:alpha: + void drawAtPoint_blendMode_alpha_( + CGPoint point, CGBlendMode blendMode, double alpha) { + _objc_msgSend_288(this.pointer, _sel_drawAtPoint_blendMode_alpha_, point, + blendMode.value, alpha); + } + + /// drawInRect: + void drawInRect_(CGRect rect) { + _objc_msgSend_81(this.pointer, _sel_drawInRect_, rect); + } + + /// drawInRect:blendMode:alpha: + void drawInRect_blendMode_alpha_( + CGRect rect, CGBlendMode blendMode, double alpha) { + _objc_msgSend_289(this.pointer, _sel_drawInRect_blendMode_alpha_, rect, + blendMode.value, alpha); + } + + /// drawAsPatternInRect: + void drawAsPatternInRect_(CGRect rect) { + _objc_msgSend_81(this.pointer, _sel_drawAsPatternInRect_, rect); + } + + /// resizableImageWithCapInsets: + UIImage resizableImageWithCapInsets_(UIEdgeInsets capInsets) { + final _ret = _objc_msgSend_290( + this.pointer, _sel_resizableImageWithCapInsets_, capInsets); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// resizableImageWithCapInsets:resizingMode: + UIImage resizableImageWithCapInsets_resizingMode_( + UIEdgeInsets capInsets, UIImageResizingMode resizingMode) { + final _ret = _objc_msgSend_291( + this.pointer, + _sel_resizableImageWithCapInsets_resizingMode_, + capInsets, + resizingMode.value); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// capInsets + void getCapInsets(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_24Stret(stret, this.pointer, _sel_capInsets) + : stret.ref = _objc_msgSend_24(this.pointer, _sel_capInsets); + } + + /// resizingMode + UIImageResizingMode get resizingMode { + final _ret = _objc_msgSend_292(this.pointer, _sel_resizingMode); + return UIImageResizingMode.fromValue(_ret); + } + + /// imageWithAlignmentRectInsets: + UIImage imageWithAlignmentRectInsets_(UIEdgeInsets alignmentInsets) { + final _ret = _objc_msgSend_290( + this.pointer, _sel_imageWithAlignmentRectInsets_, alignmentInsets); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// alignmentRectInsets + void getAlignmentRectInsets(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_24Stret(stret, this.pointer, _sel_alignmentRectInsets) + : stret.ref = _objc_msgSend_24(this.pointer, _sel_alignmentRectInsets); + } + + /// imageWithRenderingMode: + UIImage imageWithRenderingMode_(UIImageRenderingMode renderingMode) { + final _ret = _objc_msgSend_293( + this.pointer, _sel_imageWithRenderingMode_, renderingMode.value); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// renderingMode + UIImageRenderingMode get renderingMode { + final _ret = _objc_msgSend_294(this.pointer, _sel_renderingMode); + return UIImageRenderingMode.fromValue(_ret); + } + + /// imageRendererFormat + UIGraphicsImageRendererFormat get imageRendererFormat { + final _ret = _objc_msgSend_298(this.pointer, _sel_imageRendererFormat); + return UIGraphicsImageRendererFormat.castFromPointer(_ret, + retain: true, release: true); + } + + /// traitCollection + UITraitCollection get traitCollection { + final _ret = _objc_msgSend_299(this.pointer, _sel_traitCollection); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// imageAsset + UIImageAsset? get imageAsset { + final _ret = _objc_msgSend_306(this.pointer, _sel_imageAsset); + return _ret.address == 0 + ? null + : UIImageAsset.castFromPointer(_ret, retain: true, release: true); + } + + /// imageFlippedForRightToLeftLayoutDirection + UIImage imageFlippedForRightToLeftLayoutDirection() { + final _ret = _objc_msgSend_307( + this.pointer, _sel_imageFlippedForRightToLeftLayoutDirection); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// flipsForRightToLeftLayoutDirection + bool get flipsForRightToLeftLayoutDirection { + return _objc_msgSend_5( + this.pointer, _sel_flipsForRightToLeftLayoutDirection); + } + + /// imageWithHorizontallyFlippedOrientation + UIImage imageWithHorizontallyFlippedOrientation() { + final _ret = _objc_msgSend_307( + this.pointer, _sel_imageWithHorizontallyFlippedOrientation); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// baselineOffsetFromBottom + double get baselineOffsetFromBottom { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_baselineOffsetFromBottom) + : _objc_msgSend_11(this.pointer, _sel_baselineOffsetFromBottom); + } + + /// hasBaseline + bool get hasBaseline { + return _objc_msgSend_5(this.pointer, _sel_hasBaseline); + } + + /// imageWithBaselineOffsetFromBottom: + UIImage imageWithBaselineOffsetFromBottom_(double baselineOffset) { + final _ret = _objc_msgSend_308( + this.pointer, _sel_imageWithBaselineOffsetFromBottom_, baselineOffset); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithoutBaseline + UIImage imageWithoutBaseline() { + final _ret = _objc_msgSend_307(this.pointer, _sel_imageWithoutBaseline); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// configuration + UIImageConfiguration? get configuration { + final _ret = _objc_msgSend_309(this.pointer, _sel_configuration); + return _ret.address == 0 + ? null + : UIImageConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// imageWithConfiguration: + UIImage imageWithConfiguration_(UIImageConfiguration configuration) { + final _ret = _objc_msgSend_300( + this.pointer, _sel_imageWithConfiguration_, configuration.pointer); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// symbolConfiguration + UIImageSymbolConfiguration? get symbolConfiguration { + final _ret = _objc_msgSend_352(this.pointer, _sel_symbolConfiguration); + return _ret.address == 0 + ? null + : UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// imageByApplyingSymbolConfiguration: + UIImage? imageByApplyingSymbolConfiguration_( + UIImageSymbolConfiguration configuration) { + final _ret = _objc_msgSend_353(this.pointer, + _sel_imageByApplyingSymbolConfiguration_, configuration.pointer); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithTintColor: + UIImage imageWithTintColor_(UIColor color) { + final _ret = _objc_msgSend_354( + this.pointer, _sel_imageWithTintColor_, color.pointer); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithTintColor:renderingMode: + UIImage imageWithTintColor_renderingMode_( + UIColor color, UIImageRenderingMode renderingMode) { + final _ret = _objc_msgSend_355( + this.pointer, + _sel_imageWithTintColor_renderingMode_, + color.pointer, + renderingMode.value); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByPreparingForDisplay + UIImage? imageByPreparingForDisplay() { + final _ret = + _objc_msgSend_356(this.pointer, _sel_imageByPreparingForDisplay); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// prepareForDisplayWithCompletionHandler: + void prepareForDisplayWithCompletionHandler_( + ObjCBlock_ffiVoid_UIImage completionHandler) { + _objc_msgSend_357( + this.pointer, + _sel_prepareForDisplayWithCompletionHandler_, + completionHandler.pointer); + } + + /// imageByPreparingThumbnailOfSize: + UIImage? imageByPreparingThumbnailOfSize_(CGSize size) { + final _ret = _objc_msgSend_358( + this.pointer, _sel_imageByPreparingThumbnailOfSize_, size); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// prepareThumbnailOfSize:completionHandler: + void prepareThumbnailOfSize_completionHandler_( + CGSize size, ObjCBlock_ffiVoid_UIImage completionHandler) { + _objc_msgSend_359( + this.pointer, + _sel_prepareThumbnailOfSize_completionHandler_, + size, + completionHandler.pointer); + } + + /// isHighDynamicRange + bool get isHighDynamicRange { + return _objc_msgSend_5(this.pointer, _sel_isHighDynamicRange); + } + + /// imageRestrictedToStandardDynamicRange + UIImage imageRestrictedToStandardDynamicRange() { + final _ret = _objc_msgSend_307( + this.pointer, _sel_imageRestrictedToStandardDynamicRange); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIImage init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIImage new1() { + final _ret = _objc_msgSend_18(_class_UIImage, _sel_new); + return UIImage.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIImage allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIImage, _sel_allocWithZone_, zone); + return UIImage.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIImage alloc() { + final _ret = _objc_msgSend_18(_class_UIImage, _sel_alloc); + return UIImage.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIImage = objc.getClass("UIImage"); +late final _sel_systemImageNamed_ = objc.registerName("systemImageNamed:"); +final _objc_msgSend_135 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// UIImageConfiguration +class UIImageConfiguration extends objc.NSObject { + UIImageConfiguration._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIImageConfiguration] that points to the same underlying object as [other]. + UIImageConfiguration.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIImageConfiguration] that wraps the given raw object pointer. + UIImageConfiguration.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIImageConfiguration]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIImageConfiguration); + } + + /// new + static UIImageConfiguration new1() { + final _ret = _objc_msgSend_18(_class_UIImageConfiguration, _sel_new); + return UIImageConfiguration.castFromPointer(_ret, + retain: false, release: true); + } + + /// init + UIImageConfiguration init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIImageConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// traitCollection + UITraitCollection? get traitCollection { + final _ret = _objc_msgSend_166(this.pointer, _sel_traitCollection); + return _ret.address == 0 + ? null + : UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// configurationWithTraitCollection: + static UIImageConfiguration configurationWithTraitCollection_( + UITraitCollection? traitCollection) { + final _ret = _objc_msgSend_167( + _class_UIImageConfiguration, + _sel_configurationWithTraitCollection_, + traitCollection?.pointer ?? ffi.nullptr); + return UIImageConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// locale + objc.NSLocale? get locale { + final _ret = _objc_msgSend_168(this.pointer, _sel_locale); + return _ret.address == 0 + ? null + : objc.NSLocale.castFromPointer(_ret, retain: true, release: true); + } + + /// configurationWithLocale: + static UIImageConfiguration configurationWithLocale_(objc.NSLocale? locale) { + final _ret = _objc_msgSend_169(_class_UIImageConfiguration, + _sel_configurationWithLocale_, locale?.pointer ?? ffi.nullptr); + return UIImageConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationByApplyingConfiguration: + UIImageConfiguration configurationByApplyingConfiguration_( + UIImageConfiguration? otherConfiguration) { + final _ret = _objc_msgSend_170( + this.pointer, + _sel_configurationByApplyingConfiguration_, + otherConfiguration?.pointer ?? ffi.nullptr); + return UIImageConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// allocWithZone: + static UIImageConfiguration allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIImageConfiguration, _sel_allocWithZone_, zone); + return UIImageConfiguration.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIImageConfiguration alloc() { + final _ret = _objc_msgSend_18(_class_UIImageConfiguration, _sel_alloc); + return UIImageConfiguration.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIImageConfiguration = objc.getClass("UIImageConfiguration"); + +/// UITraitCollection +class UITraitCollection extends objc.NSObject { + UITraitCollection._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UITraitCollection] that points to the same underlying object as [other]. + UITraitCollection.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UITraitCollection] that wraps the given raw object pointer. + UITraitCollection.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UITraitCollection]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UITraitCollection); + } + + /// init + UITraitCollection init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UITraitCollection? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// containsTraitsInCollection: + bool containsTraitsInCollection_(UITraitCollection? trait) { + return _objc_msgSend_136(this.pointer, _sel_containsTraitsInCollection_, + trait?.pointer ?? ffi.nullptr); + } + + /// traitCollectionWithTraitsFromCollections: + static UITraitCollection traitCollectionWithTraitsFromCollections_( + objc.NSArray traitCollections) { + final _ret = _objc_msgSend_137( + _class_UITraitCollection, + _sel_traitCollectionWithTraitsFromCollections_, + traitCollections.pointer); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// traitCollectionWithUserInterfaceIdiom: + static UITraitCollection traitCollectionWithUserInterfaceIdiom_( + UIUserInterfaceIdiom idiom) { + final _ret = _objc_msgSend_138(_class_UITraitCollection, + _sel_traitCollectionWithUserInterfaceIdiom_, idiom.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// userInterfaceIdiom + UIUserInterfaceIdiom get userInterfaceIdiom { + final _ret = _objc_msgSend_139(this.pointer, _sel_userInterfaceIdiom); + return UIUserInterfaceIdiom.fromValue(_ret); + } + + /// traitCollectionWithUserInterfaceStyle: + static UITraitCollection traitCollectionWithUserInterfaceStyle_( + UIUserInterfaceStyle userInterfaceStyle) { + final _ret = _objc_msgSend_140(_class_UITraitCollection, + _sel_traitCollectionWithUserInterfaceStyle_, userInterfaceStyle.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// userInterfaceStyle + UIUserInterfaceStyle get userInterfaceStyle { + final _ret = _objc_msgSend_141(this.pointer, _sel_userInterfaceStyle); + return UIUserInterfaceStyle.fromValue(_ret); + } + + /// traitCollectionWithLayoutDirection: + static UITraitCollection traitCollectionWithLayoutDirection_( + UITraitEnvironmentLayoutDirection layoutDirection) { + final _ret = _objc_msgSend_142(_class_UITraitCollection, + _sel_traitCollectionWithLayoutDirection_, layoutDirection.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// layoutDirection + UITraitEnvironmentLayoutDirection get layoutDirection { + final _ret = _objc_msgSend_143(this.pointer, _sel_layoutDirection); + return UITraitEnvironmentLayoutDirection.fromValue(_ret); + } + + /// traitCollectionWithDisplayScale: + static UITraitCollection traitCollectionWithDisplayScale_(double scale) { + final _ret = _objc_msgSend_144( + _class_UITraitCollection, _sel_traitCollectionWithDisplayScale_, scale); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// displayScale + double get displayScale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_displayScale) + : _objc_msgSend_11(this.pointer, _sel_displayScale); + } + + /// traitCollectionWithHorizontalSizeClass: + static UITraitCollection traitCollectionWithHorizontalSizeClass_( + UIUserInterfaceSizeClass horizontalSizeClass) { + final _ret = _objc_msgSend_145( + _class_UITraitCollection, + _sel_traitCollectionWithHorizontalSizeClass_, + horizontalSizeClass.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// horizontalSizeClass + UIUserInterfaceSizeClass get horizontalSizeClass { + final _ret = _objc_msgSend_146(this.pointer, _sel_horizontalSizeClass); + return UIUserInterfaceSizeClass.fromValue(_ret); + } + + /// traitCollectionWithVerticalSizeClass: + static UITraitCollection traitCollectionWithVerticalSizeClass_( + UIUserInterfaceSizeClass verticalSizeClass) { + final _ret = _objc_msgSend_145(_class_UITraitCollection, + _sel_traitCollectionWithVerticalSizeClass_, verticalSizeClass.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// verticalSizeClass + UIUserInterfaceSizeClass get verticalSizeClass { + final _ret = _objc_msgSend_146(this.pointer, _sel_verticalSizeClass); + return UIUserInterfaceSizeClass.fromValue(_ret); + } + + /// traitCollectionWithForceTouchCapability: + static UITraitCollection traitCollectionWithForceTouchCapability_( + UIForceTouchCapability capability) { + final _ret = _objc_msgSend_147(_class_UITraitCollection, + _sel_traitCollectionWithForceTouchCapability_, capability.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// forceTouchCapability + UIForceTouchCapability get forceTouchCapability { + final _ret = _objc_msgSend_148(this.pointer, _sel_forceTouchCapability); + return UIForceTouchCapability.fromValue(_ret); + } + + /// traitCollectionWithPreferredContentSizeCategory: + static UITraitCollection traitCollectionWithPreferredContentSizeCategory_( + objc.NSString preferredContentSizeCategory) { + final _ret = _objc_msgSend_149( + _class_UITraitCollection, + _sel_traitCollectionWithPreferredContentSizeCategory_, + preferredContentSizeCategory.pointer); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// preferredContentSizeCategory + objc.NSString get preferredContentSizeCategory { + final _ret = + _objc_msgSend_77(this.pointer, _sel_preferredContentSizeCategory); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// traitCollectionWithDisplayGamut: + static UITraitCollection traitCollectionWithDisplayGamut_( + UIDisplayGamut displayGamut) { + final _ret = _objc_msgSend_150(_class_UITraitCollection, + _sel_traitCollectionWithDisplayGamut_, displayGamut.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// displayGamut + UIDisplayGamut get displayGamut { + final _ret = _objc_msgSend_151(this.pointer, _sel_displayGamut); + return UIDisplayGamut.fromValue(_ret); + } + + /// traitCollectionWithAccessibilityContrast: + static UITraitCollection traitCollectionWithAccessibilityContrast_( + UIAccessibilityContrast accessibilityContrast) { + final _ret = _objc_msgSend_152( + _class_UITraitCollection, + _sel_traitCollectionWithAccessibilityContrast_, + accessibilityContrast.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// accessibilityContrast + UIAccessibilityContrast get accessibilityContrast { + final _ret = _objc_msgSend_153(this.pointer, _sel_accessibilityContrast); + return UIAccessibilityContrast.fromValue(_ret); + } + + /// traitCollectionWithUserInterfaceLevel: + static UITraitCollection traitCollectionWithUserInterfaceLevel_( + UIUserInterfaceLevel userInterfaceLevel) { + final _ret = _objc_msgSend_154(_class_UITraitCollection, + _sel_traitCollectionWithUserInterfaceLevel_, userInterfaceLevel.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// userInterfaceLevel + UIUserInterfaceLevel get userInterfaceLevel { + final _ret = _objc_msgSend_155(this.pointer, _sel_userInterfaceLevel); + return UIUserInterfaceLevel.fromValue(_ret); + } + + /// traitCollectionWithLegibilityWeight: + static UITraitCollection traitCollectionWithLegibilityWeight_( + UILegibilityWeight legibilityWeight) { + final _ret = _objc_msgSend_156(_class_UITraitCollection, + _sel_traitCollectionWithLegibilityWeight_, legibilityWeight.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// legibilityWeight + UILegibilityWeight get legibilityWeight { + final _ret = _objc_msgSend_157(this.pointer, _sel_legibilityWeight); + return UILegibilityWeight.fromValue(_ret); + } + + /// traitCollectionWithActiveAppearance: + static UITraitCollection traitCollectionWithActiveAppearance_( + UIUserInterfaceActiveAppearance userInterfaceActiveAppearance) { + final _ret = _objc_msgSend_158( + _class_UITraitCollection, + _sel_traitCollectionWithActiveAppearance_, + userInterfaceActiveAppearance.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// activeAppearance + UIUserInterfaceActiveAppearance get activeAppearance { + final _ret = _objc_msgSend_159(this.pointer, _sel_activeAppearance); + return UIUserInterfaceActiveAppearance.fromValue(_ret); + } + + /// traitCollectionWithToolbarItemPresentationSize: + static UITraitCollection traitCollectionWithToolbarItemPresentationSize_( + UINSToolbarItemPresentationSize toolbarItemPresentationSize) { + final _ret = _objc_msgSend_160( + _class_UITraitCollection, + _sel_traitCollectionWithToolbarItemPresentationSize_, + toolbarItemPresentationSize.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// toolbarItemPresentationSize + UINSToolbarItemPresentationSize get toolbarItemPresentationSize { + final _ret = + _objc_msgSend_161(this.pointer, _sel_toolbarItemPresentationSize); + return UINSToolbarItemPresentationSize.fromValue(_ret); + } + + /// traitCollectionWithImageDynamicRange: + static UITraitCollection traitCollectionWithImageDynamicRange_( + UIImageDynamicRange imageDynamicRange) { + final _ret = _objc_msgSend_162(_class_UITraitCollection, + _sel_traitCollectionWithImageDynamicRange_, imageDynamicRange.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// imageDynamicRange + UIImageDynamicRange get imageDynamicRange { + final _ret = _objc_msgSend_163(this.pointer, _sel_imageDynamicRange); + return UIImageDynamicRange.fromValue(_ret); + } + + /// traitCollectionWithTypesettingLanguage: + static UITraitCollection traitCollectionWithTypesettingLanguage_( + objc.NSString language) { + final _ret = _objc_msgSend_149(_class_UITraitCollection, + _sel_traitCollectionWithTypesettingLanguage_, language.pointer); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// typesettingLanguage + objc.NSString get typesettingLanguage { + final _ret = _objc_msgSend_77(this.pointer, _sel_typesettingLanguage); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// traitCollectionWithSceneCaptureState: + static UITraitCollection traitCollectionWithSceneCaptureState_( + UISceneCaptureState sceneCaptureState) { + final _ret = _objc_msgSend_164(_class_UITraitCollection, + _sel_traitCollectionWithSceneCaptureState_, sceneCaptureState.value); + return UITraitCollection.castFromPointer(_ret, retain: true, release: true); + } + + /// sceneCaptureState + UISceneCaptureState get sceneCaptureState { + final _ret = _objc_msgSend_165(this.pointer, _sel_sceneCaptureState); + return UISceneCaptureState.fromValue(_ret); + } + + /// new + static UITraitCollection new1() { + final _ret = _objc_msgSend_18(_class_UITraitCollection, _sel_new); + return UITraitCollection.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UITraitCollection allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UITraitCollection, _sel_allocWithZone_, zone); + return UITraitCollection.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UITraitCollection alloc() { + final _ret = _objc_msgSend_18(_class_UITraitCollection, _sel_alloc); + return UITraitCollection.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UITraitCollection = objc.getClass("UITraitCollection"); +late final _sel_containsTraitsInCollection_ = + objc.registerName("containsTraitsInCollection:"); +final _objc_msgSend_136 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_traitCollectionWithTraitsFromCollections_ = + objc.registerName("traitCollectionWithTraitsFromCollections:"); +final _objc_msgSend_137 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +enum UIUserInterfaceIdiom { + UIUserInterfaceIdiomUnspecified(-1), + UIUserInterfaceIdiomPhone(0), + UIUserInterfaceIdiomPad(1), + UIUserInterfaceIdiomTV(2), + UIUserInterfaceIdiomCarPlay(3), + UIUserInterfaceIdiomMac(5), + UIUserInterfaceIdiomVision(6); + + final int value; + const UIUserInterfaceIdiom(this.value); + + static UIUserInterfaceIdiom fromValue(int value) => switch (value) { + -1 => UIUserInterfaceIdiomUnspecified, + 0 => UIUserInterfaceIdiomPhone, + 1 => UIUserInterfaceIdiomPad, + 2 => UIUserInterfaceIdiomTV, + 3 => UIUserInterfaceIdiomCarPlay, + 5 => UIUserInterfaceIdiomMac, + 6 => UIUserInterfaceIdiomVision, + _ => + throw ArgumentError("Unknown value for UIUserInterfaceIdiom: $value"), + }; +} + +late final _sel_traitCollectionWithUserInterfaceIdiom_ = + objc.registerName("traitCollectionWithUserInterfaceIdiom:"); +final _objc_msgSend_138 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_userInterfaceIdiom = objc.registerName("userInterfaceIdiom"); +final _objc_msgSend_139 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIUserInterfaceStyle { + UIUserInterfaceStyleUnspecified(0), + UIUserInterfaceStyleLight(1), + UIUserInterfaceStyleDark(2); + + final int value; + const UIUserInterfaceStyle(this.value); + + static UIUserInterfaceStyle fromValue(int value) => switch (value) { + 0 => UIUserInterfaceStyleUnspecified, + 1 => UIUserInterfaceStyleLight, + 2 => UIUserInterfaceStyleDark, + _ => + throw ArgumentError("Unknown value for UIUserInterfaceStyle: $value"), + }; +} + +late final _sel_traitCollectionWithUserInterfaceStyle_ = + objc.registerName("traitCollectionWithUserInterfaceStyle:"); +final _objc_msgSend_140 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_userInterfaceStyle = objc.registerName("userInterfaceStyle"); +final _objc_msgSend_141 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UITraitEnvironmentLayoutDirection { + UITraitEnvironmentLayoutDirectionUnspecified(-1), + UITraitEnvironmentLayoutDirectionLeftToRight(0), + UITraitEnvironmentLayoutDirectionRightToLeft(1); + + final int value; + const UITraitEnvironmentLayoutDirection(this.value); + + static UITraitEnvironmentLayoutDirection fromValue(int value) => + switch (value) { + -1 => UITraitEnvironmentLayoutDirectionUnspecified, + 0 => UITraitEnvironmentLayoutDirectionLeftToRight, + 1 => UITraitEnvironmentLayoutDirectionRightToLeft, + _ => throw ArgumentError( + "Unknown value for UITraitEnvironmentLayoutDirection: $value"), + }; +} + +late final _sel_traitCollectionWithLayoutDirection_ = + objc.registerName("traitCollectionWithLayoutDirection:"); +final _objc_msgSend_142 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_layoutDirection = objc.registerName("layoutDirection"); +final _objc_msgSend_143 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_traitCollectionWithDisplayScale_ = + objc.registerName("traitCollectionWithDisplayScale:"); +final _objc_msgSend_144 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_displayScale = objc.registerName("displayScale"); + +enum UIUserInterfaceSizeClass { + UIUserInterfaceSizeClassUnspecified(0), + UIUserInterfaceSizeClassCompact(1), + UIUserInterfaceSizeClassRegular(2); + + final int value; + const UIUserInterfaceSizeClass(this.value); + + static UIUserInterfaceSizeClass fromValue(int value) => switch (value) { + 0 => UIUserInterfaceSizeClassUnspecified, + 1 => UIUserInterfaceSizeClassCompact, + 2 => UIUserInterfaceSizeClassRegular, + _ => throw ArgumentError( + "Unknown value for UIUserInterfaceSizeClass: $value"), + }; +} + +late final _sel_traitCollectionWithHorizontalSizeClass_ = + objc.registerName("traitCollectionWithHorizontalSizeClass:"); +final _objc_msgSend_145 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_horizontalSizeClass = objc.registerName("horizontalSizeClass"); +final _objc_msgSend_146 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_traitCollectionWithVerticalSizeClass_ = + objc.registerName("traitCollectionWithVerticalSizeClass:"); +late final _sel_verticalSizeClass = objc.registerName("verticalSizeClass"); + +enum UIForceTouchCapability { + UIForceTouchCapabilityUnknown(0), + UIForceTouchCapabilityUnavailable(1), + UIForceTouchCapabilityAvailable(2); + + final int value; + const UIForceTouchCapability(this.value); + + static UIForceTouchCapability fromValue(int value) => switch (value) { + 0 => UIForceTouchCapabilityUnknown, + 1 => UIForceTouchCapabilityUnavailable, + 2 => UIForceTouchCapabilityAvailable, + _ => throw ArgumentError( + "Unknown value for UIForceTouchCapability: $value"), + }; +} + +late final _sel_traitCollectionWithForceTouchCapability_ = + objc.registerName("traitCollectionWithForceTouchCapability:"); +final _objc_msgSend_147 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_forceTouchCapability = + objc.registerName("forceTouchCapability"); +final _objc_msgSend_148 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_traitCollectionWithPreferredContentSizeCategory_ = + objc.registerName("traitCollectionWithPreferredContentSizeCategory:"); +final _objc_msgSend_149 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_preferredContentSizeCategory = + objc.registerName("preferredContentSizeCategory"); + +enum UIDisplayGamut { + UIDisplayGamutUnspecified(-1), + UIDisplayGamutSRGB(0), + UIDisplayGamutP3(1); + + final int value; + const UIDisplayGamut(this.value); + + static UIDisplayGamut fromValue(int value) => switch (value) { + -1 => UIDisplayGamutUnspecified, + 0 => UIDisplayGamutSRGB, + 1 => UIDisplayGamutP3, + _ => throw ArgumentError("Unknown value for UIDisplayGamut: $value"), + }; +} + +late final _sel_traitCollectionWithDisplayGamut_ = + objc.registerName("traitCollectionWithDisplayGamut:"); +final _objc_msgSend_150 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_displayGamut = objc.registerName("displayGamut"); +final _objc_msgSend_151 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIAccessibilityContrast { + UIAccessibilityContrastUnspecified(-1), + UIAccessibilityContrastNormal(0), + UIAccessibilityContrastHigh(1); + + final int value; + const UIAccessibilityContrast(this.value); + + static UIAccessibilityContrast fromValue(int value) => switch (value) { + -1 => UIAccessibilityContrastUnspecified, + 0 => UIAccessibilityContrastNormal, + 1 => UIAccessibilityContrastHigh, + _ => throw ArgumentError( + "Unknown value for UIAccessibilityContrast: $value"), + }; +} + +late final _sel_traitCollectionWithAccessibilityContrast_ = + objc.registerName("traitCollectionWithAccessibilityContrast:"); +final _objc_msgSend_152 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_accessibilityContrast = + objc.registerName("accessibilityContrast"); +final _objc_msgSend_153 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIUserInterfaceLevel { + UIUserInterfaceLevelUnspecified(-1), + UIUserInterfaceLevelBase(0), + UIUserInterfaceLevelElevated(1); + + final int value; + const UIUserInterfaceLevel(this.value); + + static UIUserInterfaceLevel fromValue(int value) => switch (value) { + -1 => UIUserInterfaceLevelUnspecified, + 0 => UIUserInterfaceLevelBase, + 1 => UIUserInterfaceLevelElevated, + _ => + throw ArgumentError("Unknown value for UIUserInterfaceLevel: $value"), + }; +} + +late final _sel_traitCollectionWithUserInterfaceLevel_ = + objc.registerName("traitCollectionWithUserInterfaceLevel:"); +final _objc_msgSend_154 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_userInterfaceLevel = objc.registerName("userInterfaceLevel"); +final _objc_msgSend_155 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UILegibilityWeight { + UILegibilityWeightUnspecified(-1), + UILegibilityWeightRegular(0), + UILegibilityWeightBold(1); + + final int value; + const UILegibilityWeight(this.value); + + static UILegibilityWeight fromValue(int value) => switch (value) { + -1 => UILegibilityWeightUnspecified, + 0 => UILegibilityWeightRegular, + 1 => UILegibilityWeightBold, + _ => + throw ArgumentError("Unknown value for UILegibilityWeight: $value"), + }; +} + +late final _sel_traitCollectionWithLegibilityWeight_ = + objc.registerName("traitCollectionWithLegibilityWeight:"); +final _objc_msgSend_156 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_legibilityWeight = objc.registerName("legibilityWeight"); +final _objc_msgSend_157 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIUserInterfaceActiveAppearance { + UIUserInterfaceActiveAppearanceUnspecified(-1), + UIUserInterfaceActiveAppearanceInactive(0), + UIUserInterfaceActiveAppearanceActive(1); + + final int value; + const UIUserInterfaceActiveAppearance(this.value); + + static UIUserInterfaceActiveAppearance fromValue(int value) => + switch (value) { + -1 => UIUserInterfaceActiveAppearanceUnspecified, + 0 => UIUserInterfaceActiveAppearanceInactive, + 1 => UIUserInterfaceActiveAppearanceActive, + _ => throw ArgumentError( + "Unknown value for UIUserInterfaceActiveAppearance: $value"), + }; +} + +late final _sel_traitCollectionWithActiveAppearance_ = + objc.registerName("traitCollectionWithActiveAppearance:"); +final _objc_msgSend_158 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_activeAppearance = objc.registerName("activeAppearance"); +final _objc_msgSend_159 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UINSToolbarItemPresentationSize { + UINSToolbarItemPresentationSizeUnspecified(-1), + UINSToolbarItemPresentationSizeRegular(0), + UINSToolbarItemPresentationSizeSmall(1), + UINSToolbarItemPresentationSizeLarge(3); + + final int value; + const UINSToolbarItemPresentationSize(this.value); + + static UINSToolbarItemPresentationSize fromValue(int value) => + switch (value) { + -1 => UINSToolbarItemPresentationSizeUnspecified, + 0 => UINSToolbarItemPresentationSizeRegular, + 1 => UINSToolbarItemPresentationSizeSmall, + 3 => UINSToolbarItemPresentationSizeLarge, + _ => throw ArgumentError( + "Unknown value for UINSToolbarItemPresentationSize: $value"), + }; +} + +late final _sel_traitCollectionWithToolbarItemPresentationSize_ = + objc.registerName("traitCollectionWithToolbarItemPresentationSize:"); +final _objc_msgSend_160 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_toolbarItemPresentationSize = + objc.registerName("toolbarItemPresentationSize"); +final _objc_msgSend_161 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIImageDynamicRange { + UIImageDynamicRangeUnspecified(-1), + UIImageDynamicRangeStandard(0), + UIImageDynamicRangeConstrainedHigh(1), + UIImageDynamicRangeHigh(2); + + final int value; + const UIImageDynamicRange(this.value); + + static UIImageDynamicRange fromValue(int value) => switch (value) { + -1 => UIImageDynamicRangeUnspecified, + 0 => UIImageDynamicRangeStandard, + 1 => UIImageDynamicRangeConstrainedHigh, + 2 => UIImageDynamicRangeHigh, + _ => + throw ArgumentError("Unknown value for UIImageDynamicRange: $value"), + }; +} + +late final _sel_traitCollectionWithImageDynamicRange_ = + objc.registerName("traitCollectionWithImageDynamicRange:"); +final _objc_msgSend_162 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_imageDynamicRange = objc.registerName("imageDynamicRange"); +final _objc_msgSend_163 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_traitCollectionWithTypesettingLanguage_ = + objc.registerName("traitCollectionWithTypesettingLanguage:"); +late final _sel_typesettingLanguage = objc.registerName("typesettingLanguage"); + +enum UISceneCaptureState { + UISceneCaptureStateUnspecified(-1), + UISceneCaptureStateInactive(0), + UISceneCaptureStateActive(1); + + final int value; + const UISceneCaptureState(this.value); + + static UISceneCaptureState fromValue(int value) => switch (value) { + -1 => UISceneCaptureStateUnspecified, + 0 => UISceneCaptureStateInactive, + 1 => UISceneCaptureStateActive, + _ => + throw ArgumentError("Unknown value for UISceneCaptureState: $value"), + }; +} + +late final _sel_traitCollectionWithSceneCaptureState_ = + objc.registerName("traitCollectionWithSceneCaptureState:"); +final _objc_msgSend_164 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_sceneCaptureState = objc.registerName("sceneCaptureState"); +final _objc_msgSend_165 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_traitCollection = objc.registerName("traitCollection"); +final _objc_msgSend_166 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_configurationWithTraitCollection_ = + objc.registerName("configurationWithTraitCollection:"); +final _objc_msgSend_167 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_locale = objc.registerName("locale"); +final _objc_msgSend_168 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_configurationWithLocale_ = + objc.registerName("configurationWithLocale:"); +final _objc_msgSend_169 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_configurationByApplyingConfiguration_ = + objc.registerName("configurationByApplyingConfiguration:"); +final _objc_msgSend_170 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_systemImageNamed_withConfiguration_ = + objc.registerName("systemImageNamed:withConfiguration:"); +final _objc_msgSend_171 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_systemImageNamed_compatibleWithTraitCollection_ = + objc.registerName("systemImageNamed:compatibleWithTraitCollection:"); +final _objc_msgSend_172 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_systemImageNamed_variableValue_withConfiguration_ = + objc.registerName("systemImageNamed:variableValue:withConfiguration:"); +final _objc_msgSend_173 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer)>(); +late final _sel_imageNamed_ = objc.registerName("imageNamed:"); + +/// NSBundle +class NSBundle extends objc.NSObject { + NSBundle._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSBundle] that points to the same underlying object as [other]. + NSBundle.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSBundle] that wraps the given raw object pointer. + NSBundle.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSBundle]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSBundle); + } + + /// mainBundle + static NSBundle getMainBundle() { + final _ret = _objc_msgSend_174(_class_NSBundle, _sel_mainBundle); + return NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleWithPath: + static NSBundle? bundleWithPath_(objc.NSString path) { + final _ret = + _objc_msgSend_57(_class_NSBundle, _sel_bundleWithPath_, path.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithPath: + NSBundle? initWithPath_(objc.NSString path) { + final _ret = + _objc_msgSend_57(this.pointer, _sel_initWithPath_, path.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleWithURL: + static NSBundle? bundleWithURL_(objc.NSURL url) { + final _ret = + _objc_msgSend_175(_class_NSBundle, _sel_bundleWithURL_, url.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithURL: + NSBundle? initWithURL_(objc.NSURL url) { + final _ret = + _objc_msgSend_175(this.pointer, _sel_initWithURL_, url.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleForClass: + static NSBundle bundleForClass_(objc.ObjCObjectBase aClass) { + final _ret = _objc_msgSend_176( + _class_NSBundle, _sel_bundleForClass_, aClass.pointer); + return NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleWithIdentifier: + static NSBundle? bundleWithIdentifier_(objc.NSString identifier) { + final _ret = _objc_msgSend_177( + _class_NSBundle, _sel_bundleWithIdentifier_, identifier.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// allBundles + static objc.NSArray getAllBundles() { + final _ret = _objc_msgSend_14(_class_NSBundle, _sel_allBundles); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// allFrameworks + static objc.NSArray getAllFrameworks() { + final _ret = _objc_msgSend_14(_class_NSBundle, _sel_allFrameworks); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// load + bool load() { + return _objc_msgSend_5(this.pointer, _sel_load); + } + + /// isLoaded + bool get loaded { + return _objc_msgSend_5(this.pointer, _sel_isLoaded); + } + + /// unload + bool unload() { + return _objc_msgSend_5(this.pointer, _sel_unload); + } + + /// preflightAndReturnError: + bool preflightAndReturnError_( + ffi.Pointer> error) { + return _objc_msgSend_178( + this.pointer, _sel_preflightAndReturnError_, error); + } + + /// loadAndReturnError: + bool loadAndReturnError_(ffi.Pointer> error) { + return _objc_msgSend_178(this.pointer, _sel_loadAndReturnError_, error); + } + + /// bundleURL + objc.NSURL get bundleURL { + final _ret = _objc_msgSend_179(this.pointer, _sel_bundleURL); + return objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// resourceURL + objc.NSURL? get resourceURL { + final _ret = _objc_msgSend_180(this.pointer, _sel_resourceURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// executableURL + objc.NSURL? get executableURL { + final _ret = _objc_msgSend_180(this.pointer, _sel_executableURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLForAuxiliaryExecutable: + objc.NSURL? URLForAuxiliaryExecutable_(objc.NSString executableName) { + final _ret = _objc_msgSend_181( + this.pointer, _sel_URLForAuxiliaryExecutable_, executableName.pointer); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// privateFrameworksURL + objc.NSURL? get privateFrameworksURL { + final _ret = _objc_msgSend_180(this.pointer, _sel_privateFrameworksURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// sharedFrameworksURL + objc.NSURL? get sharedFrameworksURL { + final _ret = _objc_msgSend_180(this.pointer, _sel_sharedFrameworksURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// sharedSupportURL + objc.NSURL? get sharedSupportURL { + final _ret = _objc_msgSend_180(this.pointer, _sel_sharedSupportURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// builtInPlugInsURL + objc.NSURL? get builtInPlugInsURL { + final _ret = _objc_msgSend_180(this.pointer, _sel_builtInPlugInsURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// appStoreReceiptURL + objc.NSURL? get appStoreReceiptURL { + final _ret = _objc_msgSend_180(this.pointer, _sel_appStoreReceiptURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// bundlePath + objc.NSString get bundlePath { + final _ret = _objc_msgSend_77(this.pointer, _sel_bundlePath); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// resourcePath + objc.NSString? get resourcePath { + final _ret = _objc_msgSend_29(this.pointer, _sel_resourcePath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// executablePath + objc.NSString? get executablePath { + final _ret = _objc_msgSend_29(this.pointer, _sel_executablePath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pathForAuxiliaryExecutable: + objc.NSString? pathForAuxiliaryExecutable_(objc.NSString executableName) { + final _ret = _objc_msgSend_182( + this.pointer, _sel_pathForAuxiliaryExecutable_, executableName.pointer); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// privateFrameworksPath + objc.NSString? get privateFrameworksPath { + final _ret = _objc_msgSend_29(this.pointer, _sel_privateFrameworksPath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// sharedFrameworksPath + objc.NSString? get sharedFrameworksPath { + final _ret = _objc_msgSend_29(this.pointer, _sel_sharedFrameworksPath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// sharedSupportPath + objc.NSString? get sharedSupportPath { + final _ret = _objc_msgSend_29(this.pointer, _sel_sharedSupportPath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// builtInPlugInsPath + objc.NSString? get builtInPlugInsPath { + final _ret = _objc_msgSend_29(this.pointer, _sel_builtInPlugInsPath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// URLForResource:withExtension:subdirectory:inBundleWithURL: + static objc.NSURL? URLForResource_withExtension_subdirectory_inBundleWithURL_( + objc.NSString? name, + objc.NSString? ext, + objc.NSString? subpath, + objc.NSURL bundleURL) { + final _ret = _objc_msgSend_183( + _class_NSBundle, + _sel_URLForResource_withExtension_subdirectory_inBundleWithURL_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + bundleURL.pointer); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLsForResourcesWithExtension:subdirectory:inBundleWithURL: + static objc.NSArray? + URLsForResourcesWithExtension_subdirectory_inBundleWithURL_( + objc.NSString? ext, objc.NSString? subpath, objc.NSURL bundleURL) { + final _ret = _objc_msgSend_184( + _class_NSBundle, + _sel_URLsForResourcesWithExtension_subdirectory_inBundleWithURL_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + bundleURL.pointer); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// URLForResource:withExtension: + objc.NSURL? URLForResource_withExtension_( + objc.NSString? name, objc.NSString? ext) { + final _ret = _objc_msgSend_185( + this.pointer, + _sel_URLForResource_withExtension_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLForResource:withExtension:subdirectory: + objc.NSURL? URLForResource_withExtension_subdirectory_( + objc.NSString? name, objc.NSString? ext, objc.NSString? subpath) { + final _ret = _objc_msgSend_186( + this.pointer, + _sel_URLForResource_withExtension_subdirectory_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLForResource:withExtension:subdirectory:localization: + objc.NSURL? URLForResource_withExtension_subdirectory_localization_( + objc.NSString? name, + objc.NSString? ext, + objc.NSString? subpath, + objc.NSString? localizationName) { + final _ret = _objc_msgSend_187( + this.pointer, + _sel_URLForResource_withExtension_subdirectory_localization_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + localizationName?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLsForResourcesWithExtension:subdirectory: + objc.NSArray? URLsForResourcesWithExtension_subdirectory_( + objc.NSString? ext, objc.NSString? subpath) { + final _ret = _objc_msgSend_188( + this.pointer, + _sel_URLsForResourcesWithExtension_subdirectory_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// URLsForResourcesWithExtension:subdirectory:localization: + objc.NSArray? URLsForResourcesWithExtension_subdirectory_localization_( + objc.NSString? ext, + objc.NSString? subpath, + objc.NSString? localizationName) { + final _ret = _objc_msgSend_189( + this.pointer, + _sel_URLsForResourcesWithExtension_subdirectory_localization_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + localizationName?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// pathForResource:ofType:inDirectory: + objc.NSString? pathForResource_ofType_inDirectory_( + objc.NSString? name, objc.NSString? ext, objc.NSString? subpath) { + final _ret = _objc_msgSend_190( + this.pointer, + _sel_pathForResource_ofType_inDirectory_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pathsForResourcesOfType:inDirectory: + objc.NSArray pathsForResourcesOfType_inDirectory_( + objc.NSString? ext, objc.NSString? subpath) { + final _ret = _objc_msgSend_191( + this.pointer, + _sel_pathsForResourcesOfType_inDirectory_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// pathForResource:ofType: + objc.NSString? pathForResource_ofType_( + objc.NSString? name, objc.NSString? ext) { + final _ret = _objc_msgSend_192(this.pointer, _sel_pathForResource_ofType_, + name?.pointer ?? ffi.nullptr, ext?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pathForResource:ofType:inDirectory:forLocalization: + objc.NSString? pathForResource_ofType_inDirectory_forLocalization_( + objc.NSString? name, + objc.NSString? ext, + objc.NSString? subpath, + objc.NSString? localizationName) { + final _ret = _objc_msgSend_193( + this.pointer, + _sel_pathForResource_ofType_inDirectory_forLocalization_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + localizationName?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pathsForResourcesOfType:inDirectory:forLocalization: + objc.NSArray pathsForResourcesOfType_inDirectory_forLocalization_( + objc.NSString? ext, + objc.NSString? subpath, + objc.NSString? localizationName) { + final _ret = _objc_msgSend_194( + this.pointer, + _sel_pathsForResourcesOfType_inDirectory_forLocalization_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + localizationName?.pointer ?? ffi.nullptr); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// localizedStringForKey:value:table: + objc.NSString localizedStringForKey_value_table_( + objc.NSString key, objc.NSString? value, objc.NSString? tableName) { + final _ret = _objc_msgSend_195( + this.pointer, + _sel_localizedStringForKey_value_table_, + key.pointer, + value?.pointer ?? ffi.nullptr, + tableName?.pointer ?? ffi.nullptr); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// localizedAttributedStringForKey:value:table: + NSAttributedString localizedAttributedStringForKey_value_table_( + objc.NSString key, objc.NSString? value, objc.NSString? tableName) { + final _ret = _objc_msgSend_197( + this.pointer, + _sel_localizedAttributedStringForKey_value_table_, + key.pointer, + value?.pointer ?? ffi.nullptr, + tableName?.pointer ?? ffi.nullptr); + return NSAttributedString.castFromPointer(_ret, + retain: true, release: true); + } + + /// bundleIdentifier + objc.NSString? get bundleIdentifier { + final _ret = _objc_msgSend_29(this.pointer, _sel_bundleIdentifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// infoDictionary + objc.NSDictionary? get infoDictionary { + final _ret = _objc_msgSend_104(this.pointer, _sel_infoDictionary); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// localizedInfoDictionary + objc.NSDictionary? get localizedInfoDictionary { + final _ret = _objc_msgSend_104(this.pointer, _sel_localizedInfoDictionary); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// objectForInfoDictionaryKey: + objc.ObjCObjectBase? objectForInfoDictionaryKey_(objc.NSString key) { + final _ret = _objc_msgSend_57( + this.pointer, _sel_objectForInfoDictionaryKey_, key.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// classNamed: + objc.ObjCObjectBase? classNamed_(objc.NSString className) { + final _ret = + _objc_msgSend_57(this.pointer, _sel_classNamed_, className.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// principalClass + objc.ObjCObjectBase? get principalClass { + final _ret = _objc_msgSend_2(this.pointer, _sel_principalClass); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// preferredLocalizations + objc.NSArray get preferredLocalizations { + final _ret = _objc_msgSend_14(this.pointer, _sel_preferredLocalizations); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// localizations + objc.NSArray get localizations { + final _ret = _objc_msgSend_14(this.pointer, _sel_localizations); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// developmentLocalization + objc.NSString? get developmentLocalization { + final _ret = _objc_msgSend_29(this.pointer, _sel_developmentLocalization); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// preferredLocalizationsFromArray: + static objc.NSArray preferredLocalizationsFromArray_( + objc.NSArray localizationsArray) { + final _ret = _objc_msgSend_198(_class_NSBundle, + _sel_preferredLocalizationsFromArray_, localizationsArray.pointer); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// preferredLocalizationsFromArray:forPreferences: + static objc.NSArray preferredLocalizationsFromArray_forPreferences_( + objc.NSArray localizationsArray, objc.NSArray? preferencesArray) { + final _ret = _objc_msgSend_199( + _class_NSBundle, + _sel_preferredLocalizationsFromArray_forPreferences_, + localizationsArray.pointer, + preferencesArray?.pointer ?? ffi.nullptr); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// executableArchitectures + objc.NSArray? get executableArchitectures { + final _ret = _objc_msgSend_90(this.pointer, _sel_executableArchitectures); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSBundle init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSBundle new1() { + final _ret = _objc_msgSend_18(_class_NSBundle, _sel_new); + return NSBundle.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSBundle allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_NSBundle, _sel_allocWithZone_, zone); + return NSBundle.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSBundle alloc() { + final _ret = _objc_msgSend_18(_class_NSBundle, _sel_alloc); + return NSBundle.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSBundle = objc.getClass("NSBundle"); +late final _sel_mainBundle = objc.registerName("mainBundle"); +final _objc_msgSend_174 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_bundleWithPath_ = objc.registerName("bundleWithPath:"); +late final _sel_initWithPath_ = objc.registerName("initWithPath:"); +late final _sel_bundleWithURL_ = objc.registerName("bundleWithURL:"); +final _objc_msgSend_175 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithURL_ = objc.registerName("initWithURL:"); +late final _sel_bundleForClass_ = objc.registerName("bundleForClass:"); +final _objc_msgSend_176 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_bundleWithIdentifier_ = + objc.registerName("bundleWithIdentifier:"); +final _objc_msgSend_177 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_allBundles = objc.registerName("allBundles"); +late final _sel_allFrameworks = objc.registerName("allFrameworks"); +late final _sel_load = objc.registerName("load"); +late final _sel_isLoaded = objc.registerName("isLoaded"); +late final _sel_unload = objc.registerName("unload"); +late final _sel_preflightAndReturnError_ = + objc.registerName("preflightAndReturnError:"); +final _objc_msgSend_178 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>)>(); +late final _sel_loadAndReturnError_ = objc.registerName("loadAndReturnError:"); +late final _sel_bundleURL = objc.registerName("bundleURL"); +final _objc_msgSend_179 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_resourceURL = objc.registerName("resourceURL"); +final _objc_msgSend_180 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_executableURL = objc.registerName("executableURL"); +late final _sel_URLForAuxiliaryExecutable_ = + objc.registerName("URLForAuxiliaryExecutable:"); +final _objc_msgSend_181 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_privateFrameworksURL = + objc.registerName("privateFrameworksURL"); +late final _sel_sharedFrameworksURL = objc.registerName("sharedFrameworksURL"); +late final _sel_sharedSupportURL = objc.registerName("sharedSupportURL"); +late final _sel_builtInPlugInsURL = objc.registerName("builtInPlugInsURL"); +late final _sel_appStoreReceiptURL = objc.registerName("appStoreReceiptURL"); +late final _sel_bundlePath = objc.registerName("bundlePath"); +late final _sel_resourcePath = objc.registerName("resourcePath"); +late final _sel_executablePath = objc.registerName("executablePath"); +late final _sel_pathForAuxiliaryExecutable_ = + objc.registerName("pathForAuxiliaryExecutable:"); +final _objc_msgSend_182 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_privateFrameworksPath = + objc.registerName("privateFrameworksPath"); +late final _sel_sharedFrameworksPath = + objc.registerName("sharedFrameworksPath"); +late final _sel_sharedSupportPath = objc.registerName("sharedSupportPath"); +late final _sel_builtInPlugInsPath = objc.registerName("builtInPlugInsPath"); +late final _sel_URLForResource_withExtension_subdirectory_inBundleWithURL_ = + objc.registerName( + "URLForResource:withExtension:subdirectory:inBundleWithURL:"); +final _objc_msgSend_183 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLsForResourcesWithExtension_subdirectory_inBundleWithURL_ = + objc.registerName( + "URLsForResourcesWithExtension:subdirectory:inBundleWithURL:"); +final _objc_msgSend_184 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLForResource_withExtension_ = + objc.registerName("URLForResource:withExtension:"); +final _objc_msgSend_185 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLForResource_withExtension_subdirectory_ = + objc.registerName("URLForResource:withExtension:subdirectory:"); +final _objc_msgSend_186 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLForResource_withExtension_subdirectory_localization_ = objc + .registerName("URLForResource:withExtension:subdirectory:localization:"); +final _objc_msgSend_187 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLsForResourcesWithExtension_subdirectory_ = + objc.registerName("URLsForResourcesWithExtension:subdirectory:"); +final _objc_msgSend_188 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLsForResourcesWithExtension_subdirectory_localization_ = objc + .registerName("URLsForResourcesWithExtension:subdirectory:localization:"); +final _objc_msgSend_189 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathForResource_ofType_inDirectory_ = + objc.registerName("pathForResource:ofType:inDirectory:"); +final _objc_msgSend_190 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathsForResourcesOfType_inDirectory_ = + objc.registerName("pathsForResourcesOfType:inDirectory:"); +final _objc_msgSend_191 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathForResource_ofType_ = + objc.registerName("pathForResource:ofType:"); +final _objc_msgSend_192 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathForResource_ofType_inDirectory_forLocalization_ = + objc.registerName("pathForResource:ofType:inDirectory:forLocalization:"); +final _objc_msgSend_193 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathsForResourcesOfType_inDirectory_forLocalization_ = + objc.registerName("pathsForResourcesOfType:inDirectory:forLocalization:"); +final _objc_msgSend_194 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_localizedStringForKey_value_table_ = + objc.registerName("localizedStringForKey:value:table:"); +final _objc_msgSend_195 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSAttributedString +class NSAttributedString extends objc.NSObject { + NSAttributedString._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSAttributedString] that points to the same underlying object as [other]. + NSAttributedString.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSAttributedString] that wraps the given raw object pointer. + NSAttributedString.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSAttributedString]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSAttributedString); + } + + /// string + objc.NSString get string { + final _ret = _objc_msgSend_77(this.pointer, _sel_string); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// attributesAtIndex:effectiveRange: + objc.NSDictionary attributesAtIndex_effectiveRange_( + int location, ffi.Pointer<_NSRange> range) { + final _ret = _objc_msgSend_196( + this.pointer, _sel_attributesAtIndex_effectiveRange_, location, range); + return objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSAttributedString init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSAttributedString.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static NSAttributedString new1() { + final _ret = _objc_msgSend_18(_class_NSAttributedString, _sel_new); + return NSAttributedString.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static NSAttributedString allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSAttributedString, _sel_allocWithZone_, zone); + return NSAttributedString.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static NSAttributedString alloc() { + final _ret = _objc_msgSend_18(_class_NSAttributedString, _sel_alloc); + return NSAttributedString.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_NSAttributedString = objc.getClass("NSAttributedString"); +late final _sel_string = objc.registerName("string"); + +final class _NSRange extends ffi.Struct { + @ffi.UnsignedLong() + external int location; + + @ffi.UnsignedLong() + external int length; +} + +late final _sel_attributesAtIndex_effectiveRange_ = + objc.registerName("attributesAtIndex:effectiveRange:"); +final _objc_msgSend_196 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer<_NSRange>)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int, ffi.Pointer<_NSRange>)>(); +late final _sel_localizedAttributedStringForKey_value_table_ = + objc.registerName("localizedAttributedStringForKey:value:table:"); +final _objc_msgSend_197 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_bundleIdentifier = objc.registerName("bundleIdentifier"); +late final _sel_infoDictionary = objc.registerName("infoDictionary"); +late final _sel_localizedInfoDictionary = + objc.registerName("localizedInfoDictionary"); +late final _sel_objectForInfoDictionaryKey_ = + objc.registerName("objectForInfoDictionaryKey:"); +late final _sel_classNamed_ = objc.registerName("classNamed:"); +late final _sel_principalClass = objc.registerName("principalClass"); +late final _sel_preferredLocalizations = + objc.registerName("preferredLocalizations"); +late final _sel_localizations = objc.registerName("localizations"); +late final _sel_developmentLocalization = + objc.registerName("developmentLocalization"); +late final _sel_preferredLocalizationsFromArray_ = + objc.registerName("preferredLocalizationsFromArray:"); +final _objc_msgSend_198 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_preferredLocalizationsFromArray_forPreferences_ = + objc.registerName("preferredLocalizationsFromArray:forPreferences:"); +final _objc_msgSend_199 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_executableArchitectures = + objc.registerName("executableArchitectures"); +late final _sel_imageNamed_inBundle_withConfiguration_ = + objc.registerName("imageNamed:inBundle:withConfiguration:"); +final _objc_msgSend_200 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_imageNamed_inBundle_compatibleWithTraitCollection_ = + objc.registerName("imageNamed:inBundle:compatibleWithTraitCollection:"); +final _objc_msgSend_201 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_imageNamed_inBundle_variableValue_withConfiguration_ = + objc.registerName("imageNamed:inBundle:variableValue:withConfiguration:"); +final _objc_msgSend_202 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer)>(); +late final _sel_imageWithContentsOfFile_ = + objc.registerName("imageWithContentsOfFile:"); +late final _sel_imageWithData_ = objc.registerName("imageWithData:"); +final _objc_msgSend_203 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithData_scale_ = + objc.registerName("imageWithData:scale:"); +final _objc_msgSend_204 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double)>(); + +final class CGImage extends ffi.Opaque {} + +late final _sel_imageWithCGImage_ = objc.registerName("imageWithCGImage:"); +final _objc_msgSend_205 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +enum UIImageOrientation { + UIImageOrientationUp(0), + UIImageOrientationDown(1), + UIImageOrientationLeft(2), + UIImageOrientationRight(3), + UIImageOrientationUpMirrored(4), + UIImageOrientationDownMirrored(5), + UIImageOrientationLeftMirrored(6), + UIImageOrientationRightMirrored(7); + + final int value; + const UIImageOrientation(this.value); + + static UIImageOrientation fromValue(int value) => switch (value) { + 0 => UIImageOrientationUp, + 1 => UIImageOrientationDown, + 2 => UIImageOrientationLeft, + 3 => UIImageOrientationRight, + 4 => UIImageOrientationUpMirrored, + 5 => UIImageOrientationDownMirrored, + 6 => UIImageOrientationLeftMirrored, + 7 => UIImageOrientationRightMirrored, + _ => + throw ArgumentError("Unknown value for UIImageOrientation: $value"), + }; +} + +late final _sel_imageWithCGImage_scale_orientation_ = + objc.registerName("imageWithCGImage:scale:orientation:"); +final _objc_msgSend_206 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + int)>(); + +/// CIImage +class CIImage extends objc.NSObject { + CIImage._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [CIImage] that points to the same underlying object as [other]. + CIImage.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CIImage] that wraps the given raw object pointer. + CIImage.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CIImage]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_CIImage); + } + + /// imageWithCGImage: + static CIImage imageWithCGImage_(ffi.Pointer image) { + final _ret = + _objc_msgSend_207(_class_CIImage, _sel_imageWithCGImage_, image); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCGImage:options: + static CIImage imageWithCGImage_options_( + ffi.Pointer image, objc.NSDictionary? options) { + final _ret = _objc_msgSend_208(_class_CIImage, + _sel_imageWithCGImage_options_, image, options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCGImageSource:index:options: + static CIImage imageWithCGImageSource_index_options_( + ffi.Pointer source, int index, objc.NSDictionary? dict) { + final _ret = _objc_msgSend_209( + _class_CIImage, + _sel_imageWithCGImageSource_index_options_, + source, + index, + dict?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCGLayer: + static CIImage imageWithCGLayer_(ffi.Pointer layer) { + final _ret = + _objc_msgSend_210(_class_CIImage, _sel_imageWithCGLayer_, layer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCGLayer:options: + static CIImage imageWithCGLayer_options_( + ffi.Pointer layer, objc.NSDictionary? options) { + final _ret = _objc_msgSend_211(_class_CIImage, + _sel_imageWithCGLayer_options_, layer, options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithBitmapData:bytesPerRow:size:format:colorSpace: + static CIImage imageWithBitmapData_bytesPerRow_size_format_colorSpace_( + objc.NSData data, + int bytesPerRow, + CGSize size, + int format, + ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_212( + _class_CIImage, + _sel_imageWithBitmapData_bytesPerRow_size_format_colorSpace_, + data.pointer, + bytesPerRow, + size, + format, + colorSpace); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithTexture:size:flipped:colorSpace: + static CIImage imageWithTexture_size_flipped_colorSpace_(int name, + CGSize size, bool flipped, ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_213( + _class_CIImage, + _sel_imageWithTexture_size_flipped_colorSpace_, + name, + size, + flipped, + colorSpace); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithTexture:size:flipped:options: + static CIImage imageWithTexture_size_flipped_options_( + int name, CGSize size, bool flipped, objc.NSDictionary? options) { + final _ret = _objc_msgSend_214( + _class_CIImage, + _sel_imageWithTexture_size_flipped_options_, + name, + size, + flipped, + options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithMTLTexture:options: + static CIImage? imageWithMTLTexture_options_( + objc.ObjCObjectBase texture, objc.NSDictionary? options) { + final _ret = _objc_msgSend_215( + _class_CIImage, + _sel_imageWithMTLTexture_options_, + texture.pointer, + options?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithContentsOfURL: + static CIImage? imageWithContentsOfURL_(objc.NSURL url) { + final _ret = _objc_msgSend_216( + _class_CIImage, _sel_imageWithContentsOfURL_, url.pointer); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithContentsOfURL:options: + static CIImage? imageWithContentsOfURL_options_( + objc.NSURL url, objc.NSDictionary? options) { + final _ret = _objc_msgSend_217( + _class_CIImage, + _sel_imageWithContentsOfURL_options_, + url.pointer, + options?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithData: + static CIImage? imageWithData_(objc.NSData data) { + final _ret = + _objc_msgSend_218(_class_CIImage, _sel_imageWithData_, data.pointer); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithData:options: + static CIImage? imageWithData_options_( + objc.NSData data, objc.NSDictionary? options) { + final _ret = _objc_msgSend_219(_class_CIImage, _sel_imageWithData_options_, + data.pointer, options?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCVImageBuffer: + static CIImage imageWithCVImageBuffer_(ffi.Pointer<__CVBuffer> imageBuffer) { + final _ret = _objc_msgSend_220( + _class_CIImage, _sel_imageWithCVImageBuffer_, imageBuffer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCVImageBuffer:options: + static CIImage imageWithCVImageBuffer_options_( + ffi.Pointer<__CVBuffer> imageBuffer, objc.NSDictionary? options) { + final _ret = _objc_msgSend_221( + _class_CIImage, + _sel_imageWithCVImageBuffer_options_, + imageBuffer, + options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCVPixelBuffer: + static CIImage imageWithCVPixelBuffer_(ffi.Pointer<__CVBuffer> pixelBuffer) { + final _ret = _objc_msgSend_220( + _class_CIImage, _sel_imageWithCVPixelBuffer_, pixelBuffer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithCVPixelBuffer:options: + static CIImage imageWithCVPixelBuffer_options_( + ffi.Pointer<__CVBuffer> pixelBuffer, objc.NSDictionary? options) { + final _ret = _objc_msgSend_221( + _class_CIImage, + _sel_imageWithCVPixelBuffer_options_, + pixelBuffer, + options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithIOSurface: + static CIImage imageWithIOSurface_(ffi.Pointer<__IOSurface> surface) { + final _ret = + _objc_msgSend_222(_class_CIImage, _sel_imageWithIOSurface_, surface); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithIOSurface:options: + static CIImage imageWithIOSurface_options_( + ffi.Pointer<__IOSurface> surface, objc.NSDictionary? options) { + final _ret = _objc_msgSend_223( + _class_CIImage, + _sel_imageWithIOSurface_options_, + surface, + options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithColor: + static CIImage imageWithColor_(CIColor color) { + final _ret = + _objc_msgSend_233(_class_CIImage, _sel_imageWithColor_, color.pointer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// emptyImage + static CIImage emptyImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_emptyImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// blackImage + static CIImage getBlackImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_blackImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// whiteImage + static CIImage getWhiteImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_whiteImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// grayImage + static CIImage getGrayImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_grayImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// redImage + static CIImage getRedImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_redImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// greenImage + static CIImage getGreenImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_greenImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// blueImage + static CIImage getBlueImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_blueImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// cyanImage + static CIImage getCyanImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_cyanImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// magentaImage + static CIImage getMagentaImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_magentaImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// yellowImage + static CIImage getYellowImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_yellowImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// clearImage + static CIImage getClearImage() { + final _ret = _objc_msgSend_234(_class_CIImage, _sel_clearImage); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCGImage: + CIImage initWithCGImage_(ffi.Pointer image) { + final _ret = _objc_msgSend_235(this.pointer, _sel_initWithCGImage_, image); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCGImage:options: + CIImage initWithCGImage_options_( + ffi.Pointer image, objc.NSDictionary? options) { + final _ret = _objc_msgSend_236(this.pointer, _sel_initWithCGImage_options_, + image, options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCGImageSource:index:options: + CIImage initWithCGImageSource_index_options_( + ffi.Pointer source, int index, objc.NSDictionary? dict) { + final _ret = _objc_msgSend_237( + this.pointer, + _sel_initWithCGImageSource_index_options_, + source, + index, + dict?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCGLayer: + CIImage initWithCGLayer_(ffi.Pointer layer) { + final _ret = _objc_msgSend_238(this.pointer, _sel_initWithCGLayer_, layer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCGLayer:options: + CIImage initWithCGLayer_options_( + ffi.Pointer layer, objc.NSDictionary? options) { + final _ret = _objc_msgSend_239(this.pointer, _sel_initWithCGLayer_options_, + layer, options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithData: + CIImage? initWithData_(objc.NSData data) { + final _ret = + _objc_msgSend_240(this.pointer, _sel_initWithData_, data.pointer); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithData:options: + CIImage? initWithData_options_(objc.NSData data, objc.NSDictionary? options) { + final _ret = _objc_msgSend_241(this.pointer, _sel_initWithData_options_, + data.pointer, options?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithBitmapData:bytesPerRow:size:format:colorSpace: + CIImage initWithBitmapData_bytesPerRow_size_format_colorSpace_( + objc.NSData data, + int bytesPerRow, + CGSize size, + int format, + ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_242( + this.pointer, + _sel_initWithBitmapData_bytesPerRow_size_format_colorSpace_, + data.pointer, + bytesPerRow, + size, + format, + colorSpace); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithTexture:size:flipped:colorSpace: + CIImage initWithTexture_size_flipped_colorSpace_(int name, CGSize size, + bool flipped, ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_243( + this.pointer, + _sel_initWithTexture_size_flipped_colorSpace_, + name, + size, + flipped, + colorSpace); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithTexture:size:flipped:options: + CIImage initWithTexture_size_flipped_options_( + int name, CGSize size, bool flipped, objc.NSDictionary? options) { + final _ret = _objc_msgSend_244( + this.pointer, + _sel_initWithTexture_size_flipped_options_, + name, + size, + flipped, + options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithMTLTexture:options: + CIImage? initWithMTLTexture_options_( + objc.ObjCObjectBase texture, objc.NSDictionary? options) { + final _ret = _objc_msgSend_245( + this.pointer, + _sel_initWithMTLTexture_options_, + texture.pointer, + options?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithContentsOfURL: + CIImage? initWithContentsOfURL_(objc.NSURL url) { + final _ret = _objc_msgSend_175( + this.pointer, _sel_initWithContentsOfURL_, url.pointer); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithContentsOfURL:options: + CIImage? initWithContentsOfURL_options_( + objc.NSURL url, objc.NSDictionary? options) { + final _ret = _objc_msgSend_246( + this.pointer, + _sel_initWithContentsOfURL_options_, + url.pointer, + options?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithIOSurface: + CIImage initWithIOSurface_(ffi.Pointer<__IOSurface> surface) { + final _ret = + _objc_msgSend_247(this.pointer, _sel_initWithIOSurface_, surface); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithIOSurface:options: + CIImage initWithIOSurface_options_( + ffi.Pointer<__IOSurface> surface, objc.NSDictionary? options) { + final _ret = _objc_msgSend_248( + this.pointer, + _sel_initWithIOSurface_options_, + surface, + options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCVImageBuffer: + CIImage initWithCVImageBuffer_(ffi.Pointer<__CVBuffer> imageBuffer) { + final _ret = _objc_msgSend_249( + this.pointer, _sel_initWithCVImageBuffer_, imageBuffer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCVImageBuffer:options: + CIImage initWithCVImageBuffer_options_( + ffi.Pointer<__CVBuffer> imageBuffer, objc.NSDictionary? options) { + final _ret = _objc_msgSend_250( + this.pointer, + _sel_initWithCVImageBuffer_options_, + imageBuffer, + options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCVPixelBuffer: + CIImage initWithCVPixelBuffer_(ffi.Pointer<__CVBuffer> pixelBuffer) { + final _ret = _objc_msgSend_249( + this.pointer, _sel_initWithCVPixelBuffer_, pixelBuffer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCVPixelBuffer:options: + CIImage initWithCVPixelBuffer_options_( + ffi.Pointer<__CVBuffer> pixelBuffer, objc.NSDictionary? options) { + final _ret = _objc_msgSend_250( + this.pointer, + _sel_initWithCVPixelBuffer_options_, + pixelBuffer, + options?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithColor: + CIImage initWithColor_(CIColor color) { + final _ret = + _objc_msgSend_251(this.pointer, _sel_initWithColor_, color.pointer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByApplyingTransform: + CIImage imageByApplyingTransform_(CGAffineTransform matrix) { + final _ret = + _objc_msgSend_252(this.pointer, _sel_imageByApplyingTransform_, matrix); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByApplyingTransform:highQualityDownsample: + CIImage imageByApplyingTransform_highQualityDownsample_( + CGAffineTransform matrix, bool highQualityDownsample) { + final _ret = _objc_msgSend_253( + this.pointer, + _sel_imageByApplyingTransform_highQualityDownsample_, + matrix, + highQualityDownsample); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByApplyingOrientation: + CIImage imageByApplyingOrientation_(int orientation) { + final _ret = _objc_msgSend_254( + this.pointer, _sel_imageByApplyingOrientation_, orientation); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageTransformForOrientation: + void imageTransformForOrientation_( + ffi.Pointer stret, int orientation) { + objc.useMsgSendVariants + ? _objc_msgSend_255Stret(stret, this.pointer, + _sel_imageTransformForOrientation_, orientation) + : stret.ref = _objc_msgSend_255( + this.pointer, _sel_imageTransformForOrientation_, orientation); + } + + /// imageByApplyingCGOrientation: + CIImage imageByApplyingCGOrientation_( + CGImagePropertyOrientation orientation) { + final _ret = _objc_msgSend_256( + this.pointer, _sel_imageByApplyingCGOrientation_, orientation.value); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageTransformForCGOrientation: + void imageTransformForCGOrientation_(ffi.Pointer stret, + CGImagePropertyOrientation orientation) { + objc.useMsgSendVariants + ? _objc_msgSend_257Stret(stret, this.pointer, + _sel_imageTransformForCGOrientation_, orientation.value) + : stret.ref = _objc_msgSend_257(this.pointer, + _sel_imageTransformForCGOrientation_, orientation.value); + } + + /// imageByCompositingOverImage: + CIImage imageByCompositingOverImage_(CIImage dest) { + final _ret = _objc_msgSend_258( + this.pointer, _sel_imageByCompositingOverImage_, dest.pointer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByCroppingToRect: + CIImage imageByCroppingToRect_(CGRect rect) { + final _ret = + _objc_msgSend_259(this.pointer, _sel_imageByCroppingToRect_, rect); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByClampingToExtent + CIImage imageByClampingToExtent() { + final _ret = _objc_msgSend_234(this.pointer, _sel_imageByClampingToExtent); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByClampingToRect: + CIImage imageByClampingToRect_(CGRect rect) { + final _ret = + _objc_msgSend_259(this.pointer, _sel_imageByClampingToRect_, rect); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByApplyingFilter:withInputParameters: + CIImage imageByApplyingFilter_withInputParameters_( + objc.NSString filterName, objc.NSDictionary? params) { + final _ret = _objc_msgSend_260( + this.pointer, + _sel_imageByApplyingFilter_withInputParameters_, + filterName.pointer, + params?.pointer ?? ffi.nullptr); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByApplyingFilter: + CIImage imageByApplyingFilter_(objc.NSString filterName) { + final _ret = _objc_msgSend_261( + this.pointer, _sel_imageByApplyingFilter_, filterName.pointer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByColorMatchingColorSpaceToWorkingSpace: + CIImage? imageByColorMatchingColorSpaceToWorkingSpace_( + ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_262(this.pointer, + _sel_imageByColorMatchingColorSpaceToWorkingSpace_, colorSpace); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByColorMatchingWorkingSpaceToColorSpace: + CIImage? imageByColorMatchingWorkingSpaceToColorSpace_( + ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_262(this.pointer, + _sel_imageByColorMatchingWorkingSpaceToColorSpace_, colorSpace); + return _ret.address == 0 + ? null + : CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByPremultiplyingAlpha + CIImage imageByPremultiplyingAlpha() { + final _ret = + _objc_msgSend_234(this.pointer, _sel_imageByPremultiplyingAlpha); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByUnpremultiplyingAlpha + CIImage imageByUnpremultiplyingAlpha() { + final _ret = + _objc_msgSend_234(this.pointer, _sel_imageByUnpremultiplyingAlpha); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageBySettingAlphaOneInExtent: + CIImage imageBySettingAlphaOneInExtent_(CGRect extent) { + final _ret = _objc_msgSend_259( + this.pointer, _sel_imageBySettingAlphaOneInExtent_, extent); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByApplyingGaussianBlurWithSigma: + CIImage imageByApplyingGaussianBlurWithSigma_(double sigma) { + final _ret = _objc_msgSend_263( + this.pointer, _sel_imageByApplyingGaussianBlurWithSigma_, sigma); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageBySettingProperties: + CIImage imageBySettingProperties_(objc.NSDictionary properties) { + final _ret = _objc_msgSend_264( + this.pointer, _sel_imageBySettingProperties_, properties.pointer); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageBySamplingLinear + CIImage imageBySamplingLinear() { + final _ret = _objc_msgSend_234(this.pointer, _sel_imageBySamplingLinear); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageBySamplingNearest + CIImage imageBySamplingNearest() { + final _ret = _objc_msgSend_234(this.pointer, _sel_imageBySamplingNearest); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByInsertingIntermediate + CIImage imageByInsertingIntermediate() { + final _ret = + _objc_msgSend_234(this.pointer, _sel_imageByInsertingIntermediate); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// imageByInsertingIntermediate: + CIImage imageByInsertingIntermediate_(bool cache) { + final _ret = _objc_msgSend_265( + this.pointer, _sel_imageByInsertingIntermediate_, cache); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// extent + void getExtent(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_extent) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_extent); + } + + /// properties + objc.NSDictionary get properties { + final _ret = _objc_msgSend_266(this.pointer, _sel_properties); + return objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// definition + CIFilterShape get definition { + final _ret = _objc_msgSend_271(this.pointer, _sel_definition); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// url + objc.NSURL? get url { + final _ret = _objc_msgSend_180(this.pointer, _sel_url); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// colorSpace + ffi.Pointer get colorSpace { + return _objc_msgSend_231(this.pointer, _sel_colorSpace); + } + + /// pixelBuffer + ffi.Pointer<__CVBuffer> get pixelBuffer { + return _objc_msgSend_272(this.pointer, _sel_pixelBuffer); + } + + /// CGImage + ffi.Pointer get CGImage1 { + return _objc_msgSend_273(this.pointer, _sel_CGImage); + } + + /// regionOfInterestForImage:inRect: + void regionOfInterestForImage_inRect_( + ffi.Pointer stret, CIImage image, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_274Stret(stret, this.pointer, + _sel_regionOfInterestForImage_inRect_, image.pointer, rect) + : stret.ref = _objc_msgSend_274(this.pointer, + _sel_regionOfInterestForImage_inRect_, image.pointer, rect); + } + + /// init + CIImage init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return CIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static CIImage new1() { + final _ret = _objc_msgSend_18(_class_CIImage, _sel_new); + return CIImage.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static CIImage allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_CIImage, _sel_allocWithZone_, zone); + return CIImage.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static CIImage alloc() { + final _ret = _objc_msgSend_18(_class_CIImage, _sel_alloc); + return CIImage.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_CIImage = objc.getClass("CIImage"); +final _objc_msgSend_207 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithCGImage_options_ = + objc.registerName("imageWithCGImage:options:"); +final _objc_msgSend_208 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +final class CGImageSource extends ffi.Opaque {} + +late final _sel_imageWithCGImageSource_index_options_ = + objc.registerName("imageWithCGImageSource:index:options:"); +final _objc_msgSend_209 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Size, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); + +final class CGLayer extends ffi.Opaque {} + +late final _sel_imageWithCGLayer_ = objc.registerName("imageWithCGLayer:"); +final _objc_msgSend_210 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithCGLayer_options_ = + objc.registerName("imageWithCGLayer:options:"); +final _objc_msgSend_211 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +final class CGColorSpace extends ffi.Opaque {} + +late final _sel_imageWithBitmapData_bytesPerRow_size_format_colorSpace_ = objc + .registerName("imageWithBitmapData:bytesPerRow:size:format:colorSpace:"); +final _objc_msgSend_212 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Size, + CGSize, + ffi.Int, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + CGSize, + int, + ffi.Pointer)>(); +late final _sel_imageWithTexture_size_flipped_colorSpace_ = + objc.registerName("imageWithTexture:size:flipped:colorSpace:"); +final _objc_msgSend_213 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedInt, + CGSize, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + CGSize, + bool, + ffi.Pointer)>(); +late final _sel_imageWithTexture_size_flipped_options_ = + objc.registerName("imageWithTexture:size:flipped:options:"); +final _objc_msgSend_214 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedInt, + CGSize, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + CGSize, + bool, + ffi.Pointer)>(); +late final _sel_imageWithMTLTexture_options_ = + objc.registerName("imageWithMTLTexture:options:"); +final _objc_msgSend_215 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_imageWithContentsOfURL_ = + objc.registerName("imageWithContentsOfURL:"); +final _objc_msgSend_216 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithContentsOfURL_options_ = + objc.registerName("imageWithContentsOfURL:options:"); +final _objc_msgSend_217 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +final _objc_msgSend_218 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithData_options_ = + objc.registerName("imageWithData:options:"); +final _objc_msgSend_219 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +final class __CVBuffer extends ffi.Opaque {} + +late final _sel_imageWithCVImageBuffer_ = + objc.registerName("imageWithCVImageBuffer:"); +final _objc_msgSend_220 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__CVBuffer>)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__CVBuffer>)>(); +late final _sel_imageWithCVImageBuffer_options_ = + objc.registerName("imageWithCVImageBuffer:options:"); +final _objc_msgSend_221 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<__CVBuffer>, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<__CVBuffer>, + ffi.Pointer)>(); +late final _sel_imageWithCVPixelBuffer_ = + objc.registerName("imageWithCVPixelBuffer:"); +late final _sel_imageWithCVPixelBuffer_options_ = + objc.registerName("imageWithCVPixelBuffer:options:"); + +final class __IOSurface extends ffi.Opaque {} + +late final _sel_imageWithIOSurface_ = objc.registerName("imageWithIOSurface:"); +final _objc_msgSend_222 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__IOSurface>)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__IOSurface>)>(); +late final _sel_imageWithIOSurface_options_ = + objc.registerName("imageWithIOSurface:options:"); +final _objc_msgSend_223 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<__IOSurface>, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<__IOSurface>, + ffi.Pointer)>(); + +/// CIColor +class CIColor extends objc.NSObject { + CIColor._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [CIColor] that points to the same underlying object as [other]. + CIColor.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CIColor] that wraps the given raw object pointer. + CIColor.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CIColor]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_CIColor); + } + + /// colorWithCGColor: + static CIColor colorWithCGColor_(ffi.Pointer c) { + final _ret = _objc_msgSend_224(_class_CIColor, _sel_colorWithCGColor_, c); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithRed:green:blue:alpha: + static CIColor colorWithRed_green_blue_alpha_( + double r, double g, double b, double a) { + final _ret = _objc_msgSend_225( + _class_CIColor, _sel_colorWithRed_green_blue_alpha_, r, g, b, a); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithRed:green:blue: + static CIColor colorWithRed_green_blue_(double r, double g, double b) { + final _ret = _objc_msgSend_226( + _class_CIColor, _sel_colorWithRed_green_blue_, r, g, b); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithRed:green:blue:alpha:colorSpace: + static CIColor? colorWithRed_green_blue_alpha_colorSpace_(double r, double g, + double b, double a, ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_227(_class_CIColor, + _sel_colorWithRed_green_blue_alpha_colorSpace_, r, g, b, a, colorSpace); + return _ret.address == 0 + ? null + : CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithRed:green:blue:colorSpace: + static CIColor? colorWithRed_green_blue_colorSpace_( + double r, double g, double b, ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_228(_class_CIColor, + _sel_colorWithRed_green_blue_colorSpace_, r, g, b, colorSpace); + return _ret.address == 0 + ? null + : CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithString: + static CIColor colorWithString_(objc.NSString representation) { + final _ret = _objc_msgSend_95( + _class_CIColor, _sel_colorWithString_, representation.pointer); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCGColor: + CIColor initWithCGColor_(ffi.Pointer c) { + final _ret = _objc_msgSend_224(this.pointer, _sel_initWithCGColor_, c); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithRed:green:blue:alpha: + CIColor initWithRed_green_blue_alpha_( + double r, double g, double b, double a) { + final _ret = _objc_msgSend_225( + this.pointer, _sel_initWithRed_green_blue_alpha_, r, g, b, a); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithRed:green:blue: + CIColor initWithRed_green_blue_(double r, double g, double b) { + final _ret = + _objc_msgSend_226(this.pointer, _sel_initWithRed_green_blue_, r, g, b); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithRed:green:blue:alpha:colorSpace: + CIColor? initWithRed_green_blue_alpha_colorSpace_(double r, double g, + double b, double a, ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_227(this.pointer, + _sel_initWithRed_green_blue_alpha_colorSpace_, r, g, b, a, colorSpace); + return _ret.address == 0 + ? null + : CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithRed:green:blue:colorSpace: + CIColor? initWithRed_green_blue_colorSpace_( + double r, double g, double b, ffi.Pointer colorSpace) { + final _ret = _objc_msgSend_228(this.pointer, + _sel_initWithRed_green_blue_colorSpace_, r, g, b, colorSpace); + return _ret.address == 0 + ? null + : CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// numberOfComponents + int get numberOfComponents { + return _objc_msgSend_229(this.pointer, _sel_numberOfComponents); + } + + /// components + ffi.Pointer get components { + return _objc_msgSend_230(this.pointer, _sel_components); + } + + /// alpha + double get alpha { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_alpha) + : _objc_msgSend_11(this.pointer, _sel_alpha); + } + + /// colorSpace + ffi.Pointer get colorSpace { + return _objc_msgSend_231(this.pointer, _sel_colorSpace); + } + + /// red + double get red { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_red) + : _objc_msgSend_11(this.pointer, _sel_red); + } + + /// green + double get green { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_green) + : _objc_msgSend_11(this.pointer, _sel_green); + } + + /// blue + double get blue { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_blue) + : _objc_msgSend_11(this.pointer, _sel_blue); + } + + /// stringRepresentation + objc.NSString get stringRepresentation { + final _ret = _objc_msgSend_77(this.pointer, _sel_stringRepresentation); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// blackColor + static CIColor getBlackColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_blackColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// whiteColor + static CIColor getWhiteColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_whiteColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// grayColor + static CIColor getGrayColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_grayColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// redColor + static CIColor getRedColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_redColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// greenColor + static CIColor getGreenColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_greenColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// blueColor + static CIColor getBlueColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_blueColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// cyanColor + static CIColor getCyanColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_cyanColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// magentaColor + static CIColor getMagentaColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_magentaColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// yellowColor + static CIColor getYellowColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_yellowColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// clearColor + static CIColor getClearColor() { + final _ret = _objc_msgSend_232(_class_CIColor, _sel_clearColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// init + CIColor init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static CIColor new1() { + final _ret = _objc_msgSend_18(_class_CIColor, _sel_new); + return CIColor.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static CIColor allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_CIColor, _sel_allocWithZone_, zone); + return CIColor.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static CIColor alloc() { + final _ret = _objc_msgSend_18(_class_CIColor, _sel_alloc); + return CIColor.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_CIColor = objc.getClass("CIColor"); +late final _sel_colorWithCGColor_ = objc.registerName("colorWithCGColor:"); +final _objc_msgSend_224 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_colorWithRed_green_blue_alpha_ = + objc.registerName("colorWithRed:green:blue:alpha:"); +final _objc_msgSend_225 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Double, + ffi.Double, + ffi.Double)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, double, double, double, double)>(); +late final _sel_colorWithRed_green_blue_ = + objc.registerName("colorWithRed:green:blue:"); +final _objc_msgSend_226 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Double, + ffi.Double)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, double, double, double)>(); +late final _sel_colorWithRed_green_blue_alpha_colorSpace_ = + objc.registerName("colorWithRed:green:blue:alpha:colorSpace:"); +final _objc_msgSend_227 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Double, + ffi.Double, + ffi.Double, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + double, + double, + double, + double, + ffi.Pointer)>(); +late final _sel_colorWithRed_green_blue_colorSpace_ = + objc.registerName("colorWithRed:green:blue:colorSpace:"); +final _objc_msgSend_228 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Double, + ffi.Double, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + double, + double, + double, + ffi.Pointer)>(); +late final _sel_colorWithString_ = objc.registerName("colorWithString:"); +late final _sel_initWithCGColor_ = objc.registerName("initWithCGColor:"); +late final _sel_initWithRed_green_blue_alpha_ = + objc.registerName("initWithRed:green:blue:alpha:"); +late final _sel_initWithRed_green_blue_ = + objc.registerName("initWithRed:green:blue:"); +late final _sel_initWithRed_green_blue_alpha_colorSpace_ = + objc.registerName("initWithRed:green:blue:alpha:colorSpace:"); +late final _sel_initWithRed_green_blue_colorSpace_ = + objc.registerName("initWithRed:green:blue:colorSpace:"); +late final _sel_numberOfComponents = objc.registerName("numberOfComponents"); +final _objc_msgSend_229 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Size Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_components = objc.registerName("components"); +final _objc_msgSend_230 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_alpha = objc.registerName("alpha"); +late final _sel_colorSpace = objc.registerName("colorSpace"); +final _objc_msgSend_231 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_red = objc.registerName("red"); +late final _sel_green = objc.registerName("green"); +late final _sel_blue = objc.registerName("blue"); +late final _sel_stringRepresentation = + objc.registerName("stringRepresentation"); +late final _sel_blackColor = objc.registerName("blackColor"); +final _objc_msgSend_232 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_whiteColor = objc.registerName("whiteColor"); +late final _sel_grayColor = objc.registerName("grayColor"); +late final _sel_redColor = objc.registerName("redColor"); +late final _sel_greenColor = objc.registerName("greenColor"); +late final _sel_blueColor = objc.registerName("blueColor"); +late final _sel_cyanColor = objc.registerName("cyanColor"); +late final _sel_magentaColor = objc.registerName("magentaColor"); +late final _sel_yellowColor = objc.registerName("yellowColor"); +late final _sel_clearColor = objc.registerName("clearColor"); +late final _sel_imageWithColor_ = objc.registerName("imageWithColor:"); +final _objc_msgSend_233 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_emptyImage = objc.registerName("emptyImage"); +final _objc_msgSend_234 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_blackImage = objc.registerName("blackImage"); +late final _sel_whiteImage = objc.registerName("whiteImage"); +late final _sel_grayImage = objc.registerName("grayImage"); +late final _sel_redImage = objc.registerName("redImage"); +late final _sel_greenImage = objc.registerName("greenImage"); +late final _sel_blueImage = objc.registerName("blueImage"); +late final _sel_cyanImage = objc.registerName("cyanImage"); +late final _sel_magentaImage = objc.registerName("magentaImage"); +late final _sel_yellowImage = objc.registerName("yellowImage"); +late final _sel_clearImage = objc.registerName("clearImage"); +late final _sel_initWithCGImage_ = objc.registerName("initWithCGImage:"); +final _objc_msgSend_235 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithCGImage_options_ = + objc.registerName("initWithCGImage:options:"); +final _objc_msgSend_236 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithCGImageSource_index_options_ = + objc.registerName("initWithCGImageSource:index:options:"); +final _objc_msgSend_237 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Size, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_initWithCGLayer_ = objc.registerName("initWithCGLayer:"); +final _objc_msgSend_238 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithCGLayer_options_ = + objc.registerName("initWithCGLayer:options:"); +final _objc_msgSend_239 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithData_ = objc.registerName("initWithData:"); +final _objc_msgSend_240 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithData_options_ = + objc.registerName("initWithData:options:"); +final _objc_msgSend_241 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithBitmapData_bytesPerRow_size_format_colorSpace_ = + objc.registerName("initWithBitmapData:bytesPerRow:size:format:colorSpace:"); +final _objc_msgSend_242 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Size, + CGSize, + ffi.Int, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + CGSize, + int, + ffi.Pointer)>(); +late final _sel_initWithTexture_size_flipped_colorSpace_ = + objc.registerName("initWithTexture:size:flipped:colorSpace:"); +final _objc_msgSend_243 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedInt, + CGSize, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + int, + CGSize, + bool, + ffi.Pointer)>(); +late final _sel_initWithTexture_size_flipped_options_ = + objc.registerName("initWithTexture:size:flipped:options:"); +final _objc_msgSend_244 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedInt, + CGSize, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + int, + CGSize, + bool, + ffi.Pointer)>(); +late final _sel_initWithMTLTexture_options_ = + objc.registerName("initWithMTLTexture:options:"); +final _objc_msgSend_245 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithContentsOfURL_ = + objc.registerName("initWithContentsOfURL:"); +late final _sel_initWithContentsOfURL_options_ = + objc.registerName("initWithContentsOfURL:options:"); +final _objc_msgSend_246 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithIOSurface_ = objc.registerName("initWithIOSurface:"); +final _objc_msgSend_247 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__IOSurface>)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__IOSurface>)>(); +late final _sel_initWithIOSurface_options_ = + objc.registerName("initWithIOSurface:options:"); +final _objc_msgSend_248 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<__IOSurface>, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<__IOSurface>, + ffi.Pointer)>(); +late final _sel_initWithCVImageBuffer_ = + objc.registerName("initWithCVImageBuffer:"); +final _objc_msgSend_249 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__CVBuffer>)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__CVBuffer>)>(); +late final _sel_initWithCVImageBuffer_options_ = + objc.registerName("initWithCVImageBuffer:options:"); +final _objc_msgSend_250 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<__CVBuffer>, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<__CVBuffer>, + ffi.Pointer)>(); +late final _sel_initWithCVPixelBuffer_ = + objc.registerName("initWithCVPixelBuffer:"); +late final _sel_initWithCVPixelBuffer_options_ = + objc.registerName("initWithCVPixelBuffer:options:"); +late final _sel_initWithColor_ = objc.registerName("initWithColor:"); +final _objc_msgSend_251 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageByApplyingTransform_ = + objc.registerName("imageByApplyingTransform:"); +final _objc_msgSend_252 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform)>(); +late final _sel_imageByApplyingTransform_highQualityDownsample_ = + objc.registerName("imageByApplyingTransform:highQualityDownsample:"); +final _objc_msgSend_253 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform, ffi.Bool)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform, bool)>(); +late final _sel_imageByApplyingOrientation_ = + objc.registerName("imageByApplyingOrientation:"); +final _objc_msgSend_254 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Int)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_imageTransformForOrientation_ = + objc.registerName("imageTransformForOrientation:"); +final _objc_msgSend_255 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGAffineTransform Function(ffi.Pointer, + ffi.Pointer, ffi.Int)>>() + .asFunction< + CGAffineTransform Function(ffi.Pointer, + ffi.Pointer, int)>(); +final _objc_msgSend_255Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Int)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + +enum CGImagePropertyOrientation { + kCGImagePropertyOrientationUp(1), + kCGImagePropertyOrientationUpMirrored(2), + kCGImagePropertyOrientationDown(3), + kCGImagePropertyOrientationDownMirrored(4), + kCGImagePropertyOrientationLeftMirrored(5), + kCGImagePropertyOrientationRight(6), + kCGImagePropertyOrientationRightMirrored(7), + kCGImagePropertyOrientationLeft(8); + + final int value; + const CGImagePropertyOrientation(this.value); + + static CGImagePropertyOrientation fromValue(int value) => switch (value) { + 1 => kCGImagePropertyOrientationUp, + 2 => kCGImagePropertyOrientationUpMirrored, + 3 => kCGImagePropertyOrientationDown, + 4 => kCGImagePropertyOrientationDownMirrored, + 5 => kCGImagePropertyOrientationLeftMirrored, + 6 => kCGImagePropertyOrientationRight, + 7 => kCGImagePropertyOrientationRightMirrored, + 8 => kCGImagePropertyOrientationLeft, + _ => throw ArgumentError( + "Unknown value for CGImagePropertyOrientation: $value"), + }; +} + +late final _sel_imageByApplyingCGOrientation_ = + objc.registerName("imageByApplyingCGOrientation:"); +final _objc_msgSend_256 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Uint32)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_imageTransformForCGOrientation_ = + objc.registerName("imageTransformForCGOrientation:"); +final _objc_msgSend_257 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGAffineTransform Function(ffi.Pointer, + ffi.Pointer, ffi.Uint32)>>() + .asFunction< + CGAffineTransform Function(ffi.Pointer, + ffi.Pointer, int)>(); +final _objc_msgSend_257Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Uint32)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_imageByCompositingOverImage_ = + objc.registerName("imageByCompositingOverImage:"); +final _objc_msgSend_258 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageByCroppingToRect_ = + objc.registerName("imageByCroppingToRect:"); +final _objc_msgSend_259 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_imageByClampingToExtent = + objc.registerName("imageByClampingToExtent"); +late final _sel_imageByClampingToRect_ = + objc.registerName("imageByClampingToRect:"); +late final _sel_imageByApplyingFilter_withInputParameters_ = + objc.registerName("imageByApplyingFilter:withInputParameters:"); +final _objc_msgSend_260 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_imageByApplyingFilter_ = + objc.registerName("imageByApplyingFilter:"); +final _objc_msgSend_261 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageByColorMatchingColorSpaceToWorkingSpace_ = + objc.registerName("imageByColorMatchingColorSpaceToWorkingSpace:"); +final _objc_msgSend_262 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageByColorMatchingWorkingSpaceToColorSpace_ = + objc.registerName("imageByColorMatchingWorkingSpaceToColorSpace:"); +late final _sel_imageByPremultiplyingAlpha = + objc.registerName("imageByPremultiplyingAlpha"); +late final _sel_imageByUnpremultiplyingAlpha = + objc.registerName("imageByUnpremultiplyingAlpha"); +late final _sel_imageBySettingAlphaOneInExtent_ = + objc.registerName("imageBySettingAlphaOneInExtent:"); +late final _sel_imageByApplyingGaussianBlurWithSigma_ = + objc.registerName("imageByApplyingGaussianBlurWithSigma:"); +final _objc_msgSend_263 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_imageBySettingProperties_ = + objc.registerName("imageBySettingProperties:"); +final _objc_msgSend_264 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageBySamplingLinear = + objc.registerName("imageBySamplingLinear"); +late final _sel_imageBySamplingNearest = + objc.registerName("imageBySamplingNearest"); +late final _sel_imageByInsertingIntermediate = + objc.registerName("imageByInsertingIntermediate"); +late final _sel_imageByInsertingIntermediate_ = + objc.registerName("imageByInsertingIntermediate:"); +final _objc_msgSend_265 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Bool)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, bool)>(); +late final _sel_extent = objc.registerName("extent"); +late final _sel_properties = objc.registerName("properties"); +final _objc_msgSend_266 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// CIFilterShape +class CIFilterShape extends objc.NSObject { + CIFilterShape._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [CIFilterShape] that points to the same underlying object as [other]. + CIFilterShape.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CIFilterShape] that wraps the given raw object pointer. + CIFilterShape.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CIFilterShape]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_CIFilterShape); + } + + /// shapeWithRect: + static CIFilterShape shapeWithRect_(CGRect r) { + final _ret = _objc_msgSend_54(_class_CIFilterShape, _sel_shapeWithRect_, r); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithRect: + CIFilterShape initWithRect_(CGRect r) { + final _ret = _objc_msgSend_54(this.pointer, _sel_initWithRect_, r); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// transformBy:interior: + CIFilterShape transformBy_interior_(CGAffineTransform m, bool flag) { + final _ret = + _objc_msgSend_267(this.pointer, _sel_transformBy_interior_, m, flag); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// insetByX:Y: + CIFilterShape insetByX_Y_(int dx, int dy) { + final _ret = _objc_msgSend_268(this.pointer, _sel_insetByX_Y_, dx, dy); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// unionWith: + CIFilterShape unionWith_(CIFilterShape s2) { + final _ret = _objc_msgSend_269(this.pointer, _sel_unionWith_, s2.pointer); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// unionWithRect: + CIFilterShape unionWithRect_(CGRect r) { + final _ret = _objc_msgSend_270(this.pointer, _sel_unionWithRect_, r); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// intersectWith: + CIFilterShape intersectWith_(CIFilterShape s2) { + final _ret = + _objc_msgSend_269(this.pointer, _sel_intersectWith_, s2.pointer); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// intersectWithRect: + CIFilterShape intersectWithRect_(CGRect r) { + final _ret = _objc_msgSend_270(this.pointer, _sel_intersectWithRect_, r); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// extent + void getExtent(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_extent) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_extent); + } + + /// init + CIFilterShape init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return CIFilterShape.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static CIFilterShape new1() { + final _ret = _objc_msgSend_18(_class_CIFilterShape, _sel_new); + return CIFilterShape.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static CIFilterShape allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_CIFilterShape, _sel_allocWithZone_, zone); + return CIFilterShape.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static CIFilterShape alloc() { + final _ret = _objc_msgSend_18(_class_CIFilterShape, _sel_alloc); + return CIFilterShape.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_CIFilterShape = objc.getClass("CIFilterShape"); +late final _sel_shapeWithRect_ = objc.registerName("shapeWithRect:"); +late final _sel_initWithRect_ = objc.registerName("initWithRect:"); +late final _sel_transformBy_interior_ = + objc.registerName("transformBy:interior:"); +final _objc_msgSend_267 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform, ffi.Bool)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform, bool)>(); +late final _sel_insetByX_Y_ = objc.registerName("insetByX:Y:"); +final _objc_msgSend_268 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Int, ffi.Int)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int, int)>(); +late final _sel_unionWith_ = objc.registerName("unionWith:"); +final _objc_msgSend_269 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_unionWithRect_ = objc.registerName("unionWithRect:"); +final _objc_msgSend_270 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_intersectWith_ = objc.registerName("intersectWith:"); +late final _sel_intersectWithRect_ = objc.registerName("intersectWithRect:"); +late final _sel_definition = objc.registerName("definition"); +final _objc_msgSend_271 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_url = objc.registerName("url"); +late final _sel_pixelBuffer = objc.registerName("pixelBuffer"); +final _objc_msgSend_272 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer<__CVBuffer> Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer<__CVBuffer> Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_CGImage = objc.registerName("CGImage"); +final _objc_msgSend_273 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_regionOfInterestForImage_inRect_ = + objc.registerName("regionOfInterestForImage:inRect:"); +final _objc_msgSend_274 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect)>>() + .asFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect)>(); +final _objc_msgSend_274Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect)>(); +late final _sel_imageWithCIImage_ = objc.registerName("imageWithCIImage:"); +final _objc_msgSend_275 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithCIImage_scale_orientation_ = + objc.registerName("imageWithCIImage:scale:orientation:"); +final _objc_msgSend_276 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + int)>(); +late final _sel_initWithContentsOfFile_ = + objc.registerName("initWithContentsOfFile:"); +late final _sel_initWithData_scale_ = objc.registerName("initWithData:scale:"); +final _objc_msgSend_277 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double)>(); +late final _sel_initWithCGImage_scale_orientation_ = + objc.registerName("initWithCGImage:scale:orientation:"); +final _objc_msgSend_278 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + int)>(); +late final _sel_initWithCIImage_ = objc.registerName("initWithCIImage:"); +final _objc_msgSend_279 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithCIImage_scale_orientation_ = + objc.registerName("initWithCIImage:scale:orientation:"); +final _objc_msgSend_280 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + int)>(); +late final _sel_CIImage = objc.registerName("CIImage"); +final _objc_msgSend_281 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageOrientation = objc.registerName("imageOrientation"); +final _objc_msgSend_282 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isSymbolImage = objc.registerName("isSymbolImage"); +late final _sel_animatedImageNamed_duration_ = + objc.registerName("animatedImageNamed:duration:"); +final _objc_msgSend_283 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double)>(); +late final _sel_animatedResizableImageNamed_capInsets_duration_ = + objc.registerName("animatedResizableImageNamed:capInsets:duration:"); +final _objc_msgSend_284 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + UIEdgeInsets, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + UIEdgeInsets, + double)>(); + +enum UIImageResizingMode { + UIImageResizingModeTile(0), + UIImageResizingModeStretch(1); + + final int value; + const UIImageResizingMode(this.value); + + static UIImageResizingMode fromValue(int value) => switch (value) { + 0 => UIImageResizingModeTile, + 1 => UIImageResizingModeStretch, + _ => + throw ArgumentError("Unknown value for UIImageResizingMode: $value"), + }; +} + +late final _sel_animatedResizableImageNamed_capInsets_resizingMode_duration_ = + objc.registerName( + "animatedResizableImageNamed:capInsets:resizingMode:duration:"); +final _objc_msgSend_285 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + UIEdgeInsets, + ffi.UnsignedLong, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + UIEdgeInsets, + int, + double)>(); +late final _sel_animatedImageWithImages_duration_ = + objc.registerName("animatedImageWithImages:duration:"); +final _objc_msgSend_286 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double)>(); +late final _sel_images = objc.registerName("images"); +late final _sel_drawAtPoint_ = objc.registerName("drawAtPoint:"); +final _objc_msgSend_287 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGPoint)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGPoint)>(); + +enum CGBlendMode { + kCGBlendModeNormal(0), + kCGBlendModeMultiply(1), + kCGBlendModeScreen(2), + kCGBlendModeOverlay(3), + kCGBlendModeDarken(4), + kCGBlendModeLighten(5), + kCGBlendModeColorDodge(6), + kCGBlendModeColorBurn(7), + kCGBlendModeSoftLight(8), + kCGBlendModeHardLight(9), + kCGBlendModeDifference(10), + kCGBlendModeExclusion(11), + kCGBlendModeHue(12), + kCGBlendModeSaturation(13), + kCGBlendModeColor(14), + kCGBlendModeLuminosity(15), + kCGBlendModeClear(16), + kCGBlendModeCopy(17), + kCGBlendModeSourceIn(18), + kCGBlendModeSourceOut(19), + kCGBlendModeSourceAtop(20), + kCGBlendModeDestinationOver(21), + kCGBlendModeDestinationIn(22), + kCGBlendModeDestinationOut(23), + kCGBlendModeDestinationAtop(24), + kCGBlendModeXOR(25), + kCGBlendModePlusDarker(26), + kCGBlendModePlusLighter(27); + + final int value; + const CGBlendMode(this.value); + + static CGBlendMode fromValue(int value) => switch (value) { + 0 => kCGBlendModeNormal, + 1 => kCGBlendModeMultiply, + 2 => kCGBlendModeScreen, + 3 => kCGBlendModeOverlay, + 4 => kCGBlendModeDarken, + 5 => kCGBlendModeLighten, + 6 => kCGBlendModeColorDodge, + 7 => kCGBlendModeColorBurn, + 8 => kCGBlendModeSoftLight, + 9 => kCGBlendModeHardLight, + 10 => kCGBlendModeDifference, + 11 => kCGBlendModeExclusion, + 12 => kCGBlendModeHue, + 13 => kCGBlendModeSaturation, + 14 => kCGBlendModeColor, + 15 => kCGBlendModeLuminosity, + 16 => kCGBlendModeClear, + 17 => kCGBlendModeCopy, + 18 => kCGBlendModeSourceIn, + 19 => kCGBlendModeSourceOut, + 20 => kCGBlendModeSourceAtop, + 21 => kCGBlendModeDestinationOver, + 22 => kCGBlendModeDestinationIn, + 23 => kCGBlendModeDestinationOut, + 24 => kCGBlendModeDestinationAtop, + 25 => kCGBlendModeXOR, + 26 => kCGBlendModePlusDarker, + 27 => kCGBlendModePlusLighter, + _ => throw ArgumentError("Unknown value for CGBlendMode: $value"), + }; +} + +late final _sel_drawAtPoint_blendMode_alpha_ = + objc.registerName("drawAtPoint:blendMode:alpha:"); +final _objc_msgSend_288 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Int32, + ffi.Double)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGPoint, int, double)>(); +late final _sel_drawInRect_ = objc.registerName("drawInRect:"); +late final _sel_drawInRect_blendMode_alpha_ = + objc.registerName("drawInRect:blendMode:alpha:"); +final _objc_msgSend_289 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Int32, + ffi.Double)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGRect, int, double)>(); +late final _sel_drawAsPatternInRect_ = + objc.registerName("drawAsPatternInRect:"); +late final _sel_resizableImageWithCapInsets_ = + objc.registerName("resizableImageWithCapInsets:"); +final _objc_msgSend_290 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, UIEdgeInsets)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, UIEdgeInsets)>(); +late final _sel_resizableImageWithCapInsets_resizingMode_ = + objc.registerName("resizableImageWithCapInsets:resizingMode:"); +final _objc_msgSend_291 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + UIEdgeInsets, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, UIEdgeInsets, int)>(); +late final _sel_capInsets = objc.registerName("capInsets"); +late final _sel_resizingMode = objc.registerName("resizingMode"); +final _objc_msgSend_292 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithAlignmentRectInsets_ = + objc.registerName("imageWithAlignmentRectInsets:"); +late final _sel_alignmentRectInsets = objc.registerName("alignmentRectInsets"); + +enum UIImageRenderingMode { + UIImageRenderingModeAutomatic(0), + UIImageRenderingModeAlwaysOriginal(1), + UIImageRenderingModeAlwaysTemplate(2); + + final int value; + const UIImageRenderingMode(this.value); + + static UIImageRenderingMode fromValue(int value) => switch (value) { + 0 => UIImageRenderingModeAutomatic, + 1 => UIImageRenderingModeAlwaysOriginal, + 2 => UIImageRenderingModeAlwaysTemplate, + _ => + throw ArgumentError("Unknown value for UIImageRenderingMode: $value"), + }; +} + +late final _sel_imageWithRenderingMode_ = + objc.registerName("imageWithRenderingMode:"); +final _objc_msgSend_293 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_renderingMode = objc.registerName("renderingMode"); +final _objc_msgSend_294 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UIGraphicsImageRendererFormat +class UIGraphicsImageRendererFormat extends UIGraphicsRendererFormat { + UIGraphicsImageRendererFormat._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIGraphicsImageRendererFormat] that points to the same underlying object as [other]. + UIGraphicsImageRendererFormat.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIGraphicsImageRendererFormat] that wraps the given raw object pointer. + UIGraphicsImageRendererFormat.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIGraphicsImageRendererFormat]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIGraphicsImageRendererFormat); + } + + /// scale + double get scale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_scale) + : _objc_msgSend_11(this.pointer, _sel_scale); + } + + /// setScale: + set scale(double value) { + return _objc_msgSend_26(this.pointer, _sel_setScale_, value); + } + + /// opaque + bool get opaque { + return _objc_msgSend_5(this.pointer, _sel_opaque); + } + + /// setOpaque: + set opaque(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setOpaque_, value); + } + + /// prefersExtendedRange + bool get prefersExtendedRange { + return _objc_msgSend_5(this.pointer, _sel_prefersExtendedRange); + } + + /// setPrefersExtendedRange: + set prefersExtendedRange(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setPrefersExtendedRange_, value); + } + + /// supportsHighDynamicRange + bool get supportsHighDynamicRange { + return _objc_msgSend_5(this.pointer, _sel_supportsHighDynamicRange); + } + + /// preferredRange + UIGraphicsImageRendererFormatRange get preferredRange { + final _ret = _objc_msgSend_295(this.pointer, _sel_preferredRange); + return UIGraphicsImageRendererFormatRange.fromValue(_ret); + } + + /// setPreferredRange: + set preferredRange(UIGraphicsImageRendererFormatRange value) { + return _objc_msgSend_296( + this.pointer, _sel_setPreferredRange_, value.value); + } + + /// formatForTraitCollection: + static UIGraphicsImageRendererFormat formatForTraitCollection_( + UITraitCollection traitCollection) { + final _ret = _objc_msgSend_297(_class_UIGraphicsImageRendererFormat, + _sel_formatForTraitCollection_, traitCollection.pointer); + return UIGraphicsImageRendererFormat.castFromPointer(_ret, + retain: true, release: true); + } + + /// defaultFormat + static UIGraphicsImageRendererFormat defaultFormat() { + final _ret = _objc_msgSend_18( + _class_UIGraphicsImageRendererFormat, _sel_defaultFormat); + return UIGraphicsImageRendererFormat.castFromPointer(_ret, + retain: true, release: true); + } + + /// preferredFormat + static UIGraphicsImageRendererFormat preferredFormat() { + final _ret = _objc_msgSend_18( + _class_UIGraphicsImageRendererFormat, _sel_preferredFormat); + return UIGraphicsImageRendererFormat.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UIGraphicsImageRendererFormat init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIGraphicsImageRendererFormat.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIGraphicsImageRendererFormat new1() { + final _ret = + _objc_msgSend_18(_class_UIGraphicsImageRendererFormat, _sel_new); + return UIGraphicsImageRendererFormat.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIGraphicsImageRendererFormat allocWithZone_( + ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIGraphicsImageRendererFormat, _sel_allocWithZone_, zone); + return UIGraphicsImageRendererFormat.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIGraphicsImageRendererFormat alloc() { + final _ret = + _objc_msgSend_18(_class_UIGraphicsImageRendererFormat, _sel_alloc); + return UIGraphicsImageRendererFormat.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIGraphicsImageRendererFormat = + objc.getClass("UIGraphicsImageRendererFormat"); +late final _sel_setScale_ = objc.registerName("setScale:"); +late final _sel_opaque = objc.registerName("opaque"); +late final _sel_prefersExtendedRange = + objc.registerName("prefersExtendedRange"); +late final _sel_setPrefersExtendedRange_ = + objc.registerName("setPrefersExtendedRange:"); +late final _sel_supportsHighDynamicRange = + objc.registerName("supportsHighDynamicRange"); + +enum UIGraphicsImageRendererFormatRange { + UIGraphicsImageRendererFormatRangeUnspecified(-1), + UIGraphicsImageRendererFormatRangeAutomatic(0), + UIGraphicsImageRendererFormatRangeExtended(1), + UIGraphicsImageRendererFormatRangeStandard(2); + + final int value; + const UIGraphicsImageRendererFormatRange(this.value); + + static UIGraphicsImageRendererFormatRange fromValue(int value) => + switch (value) { + -1 => UIGraphicsImageRendererFormatRangeUnspecified, + 0 => UIGraphicsImageRendererFormatRangeAutomatic, + 1 => UIGraphicsImageRendererFormatRangeExtended, + 2 => UIGraphicsImageRendererFormatRangeStandard, + _ => throw ArgumentError( + "Unknown value for UIGraphicsImageRendererFormatRange: $value"), + }; +} + +late final _sel_preferredRange = objc.registerName("preferredRange"); +final _objc_msgSend_295 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setPreferredRange_ = objc.registerName("setPreferredRange:"); +final _objc_msgSend_296 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_formatForTraitCollection_ = + objc.registerName("formatForTraitCollection:"); +final _objc_msgSend_297 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// UIGraphicsRendererFormat +class UIGraphicsRendererFormat extends objc.NSObject { + UIGraphicsRendererFormat._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIGraphicsRendererFormat] that points to the same underlying object as [other]. + UIGraphicsRendererFormat.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIGraphicsRendererFormat] that wraps the given raw object pointer. + UIGraphicsRendererFormat.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIGraphicsRendererFormat]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIGraphicsRendererFormat); + } + + /// defaultFormat + static UIGraphicsRendererFormat defaultFormat() { + final _ret = + _objc_msgSend_18(_class_UIGraphicsRendererFormat, _sel_defaultFormat); + return UIGraphicsRendererFormat.castFromPointer(_ret, + retain: true, release: true); + } + + /// preferredFormat + static UIGraphicsRendererFormat preferredFormat() { + final _ret = + _objc_msgSend_18(_class_UIGraphicsRendererFormat, _sel_preferredFormat); + return UIGraphicsRendererFormat.castFromPointer(_ret, + retain: true, release: true); + } + + /// bounds + void getBounds(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_bounds) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_bounds); + } + + /// init + UIGraphicsRendererFormat init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIGraphicsRendererFormat.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIGraphicsRendererFormat new1() { + final _ret = _objc_msgSend_18(_class_UIGraphicsRendererFormat, _sel_new); + return UIGraphicsRendererFormat.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIGraphicsRendererFormat allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIGraphicsRendererFormat, _sel_allocWithZone_, zone); + return UIGraphicsRendererFormat.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIGraphicsRendererFormat alloc() { + final _ret = _objc_msgSend_18(_class_UIGraphicsRendererFormat, _sel_alloc); + return UIGraphicsRendererFormat.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIGraphicsRendererFormat = + objc.getClass("UIGraphicsRendererFormat"); +late final _sel_defaultFormat = objc.registerName("defaultFormat"); +late final _sel_preferredFormat = objc.registerName("preferredFormat"); +late final _sel_imageRendererFormat = objc.registerName("imageRendererFormat"); +final _objc_msgSend_298 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_299 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UIImageAsset +class UIImageAsset extends objc.NSObject { + UIImageAsset._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIImageAsset] that points to the same underlying object as [other]. + UIImageAsset.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIImageAsset] that wraps the given raw object pointer. + UIImageAsset.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIImageAsset]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIImageAsset); + } + + /// init + UIImageAsset init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIImageAsset.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIImageAsset? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIImageAsset.castFromPointer(_ret, retain: true, release: true); + } + + /// imageWithConfiguration: + UIImage imageWithConfiguration_(UIImageConfiguration configuration) { + final _ret = _objc_msgSend_300( + this.pointer, _sel_imageWithConfiguration_, configuration.pointer); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// registerImage:withConfiguration: + void registerImage_withConfiguration_( + UIImage image, UIImageConfiguration configuration) { + _objc_msgSend_301(this.pointer, _sel_registerImage_withConfiguration_, + image.pointer, configuration.pointer); + } + + /// unregisterImageWithConfiguration: + void unregisterImageWithConfiguration_(UIImageConfiguration configuration) { + _objc_msgSend_302(this.pointer, _sel_unregisterImageWithConfiguration_, + configuration.pointer); + } + + /// imageWithTraitCollection: + UIImage imageWithTraitCollection_(UITraitCollection traitCollection) { + final _ret = _objc_msgSend_303( + this.pointer, _sel_imageWithTraitCollection_, traitCollection.pointer); + return UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// registerImage:withTraitCollection: + void registerImage_withTraitCollection_( + UIImage image, UITraitCollection traitCollection) { + _objc_msgSend_304(this.pointer, _sel_registerImage_withTraitCollection_, + image.pointer, traitCollection.pointer); + } + + /// unregisterImageWithTraitCollection: + void unregisterImageWithTraitCollection_(UITraitCollection traitCollection) { + _objc_msgSend_305(this.pointer, _sel_unregisterImageWithTraitCollection_, + traitCollection.pointer); + } + + /// new + static UIImageAsset new1() { + final _ret = _objc_msgSend_18(_class_UIImageAsset, _sel_new); + return UIImageAsset.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIImageAsset allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIImageAsset, _sel_allocWithZone_, zone); + return UIImageAsset.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIImageAsset alloc() { + final _ret = _objc_msgSend_18(_class_UIImageAsset, _sel_alloc); + return UIImageAsset.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIImageAsset = objc.getClass("UIImageAsset"); +late final _sel_imageWithConfiguration_ = + objc.registerName("imageWithConfiguration:"); +final _objc_msgSend_300 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_registerImage_withConfiguration_ = + objc.registerName("registerImage:withConfiguration:"); +final _objc_msgSend_301 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_unregisterImageWithConfiguration_ = + objc.registerName("unregisterImageWithConfiguration:"); +final _objc_msgSend_302 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithTraitCollection_ = + objc.registerName("imageWithTraitCollection:"); +final _objc_msgSend_303 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_registerImage_withTraitCollection_ = + objc.registerName("registerImage:withTraitCollection:"); +final _objc_msgSend_304 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_unregisterImageWithTraitCollection_ = + objc.registerName("unregisterImageWithTraitCollection:"); +final _objc_msgSend_305 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageAsset = objc.registerName("imageAsset"); +final _objc_msgSend_306 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageFlippedForRightToLeftLayoutDirection = + objc.registerName("imageFlippedForRightToLeftLayoutDirection"); +final _objc_msgSend_307 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_flipsForRightToLeftLayoutDirection = + objc.registerName("flipsForRightToLeftLayoutDirection"); +late final _sel_imageWithHorizontallyFlippedOrientation = + objc.registerName("imageWithHorizontallyFlippedOrientation"); +late final _sel_baselineOffsetFromBottom = + objc.registerName("baselineOffsetFromBottom"); +late final _sel_hasBaseline = objc.registerName("hasBaseline"); +late final _sel_imageWithBaselineOffsetFromBottom_ = + objc.registerName("imageWithBaselineOffsetFromBottom:"); +final _objc_msgSend_308 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_imageWithoutBaseline = + objc.registerName("imageWithoutBaseline"); +late final _sel_configuration = objc.registerName("configuration"); +final _objc_msgSend_309 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UIImageSymbolConfiguration +class UIImageSymbolConfiguration extends UIImageConfiguration { + UIImageSymbolConfiguration._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIImageSymbolConfiguration] that points to the same underlying object as [other]. + UIImageSymbolConfiguration.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIImageSymbolConfiguration] that wraps the given raw object pointer. + UIImageSymbolConfiguration.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIImageSymbolConfiguration]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIImageSymbolConfiguration); + } + + /// unspecifiedConfiguration + static UIImageSymbolConfiguration getUnspecifiedConfiguration() { + final _ret = _objc_msgSend_310( + _class_UIImageSymbolConfiguration, _sel_unspecifiedConfiguration); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithScale: + static UIImageSymbolConfiguration configurationWithScale_( + UIImageSymbolScale scale) { + final _ret = _objc_msgSend_311(_class_UIImageSymbolConfiguration, + _sel_configurationWithScale_, scale.value); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithPointSize: + static UIImageSymbolConfiguration configurationWithPointSize_( + double pointSize) { + final _ret = _objc_msgSend_312(_class_UIImageSymbolConfiguration, + _sel_configurationWithPointSize_, pointSize); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithWeight: + static UIImageSymbolConfiguration configurationWithWeight_( + UIImageSymbolWeight weight) { + final _ret = _objc_msgSend_313(_class_UIImageSymbolConfiguration, + _sel_configurationWithWeight_, weight.value); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithPointSize:weight: + static UIImageSymbolConfiguration configurationWithPointSize_weight_( + double pointSize, UIImageSymbolWeight weight) { + final _ret = _objc_msgSend_314(_class_UIImageSymbolConfiguration, + _sel_configurationWithPointSize_weight_, pointSize, weight.value); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithPointSize:weight:scale: + static UIImageSymbolConfiguration configurationWithPointSize_weight_scale_( + double pointSize, UIImageSymbolWeight weight, UIImageSymbolScale scale) { + final _ret = _objc_msgSend_315( + _class_UIImageSymbolConfiguration, + _sel_configurationWithPointSize_weight_scale_, + pointSize, + weight.value, + scale.value); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithTextStyle: + static UIImageSymbolConfiguration configurationWithTextStyle_( + objc.NSString textStyle) { + final _ret = _objc_msgSend_95(_class_UIImageSymbolConfiguration, + _sel_configurationWithTextStyle_, textStyle.pointer); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithTextStyle:scale: + static UIImageSymbolConfiguration configurationWithTextStyle_scale_( + objc.NSString textStyle, UIImageSymbolScale scale) { + final _ret = _objc_msgSend_316(_class_UIImageSymbolConfiguration, + _sel_configurationWithTextStyle_scale_, textStyle.pointer, scale.value); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithFont: + static UIImageSymbolConfiguration configurationWithFont_(UIFont font) { + final _ret = _objc_msgSend_338(_class_UIImageSymbolConfiguration, + _sel_configurationWithFont_, font.pointer); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithFont:scale: + static UIImageSymbolConfiguration configurationWithFont_scale_( + UIFont font, UIImageSymbolScale scale) { + final _ret = _objc_msgSend_339(_class_UIImageSymbolConfiguration, + _sel_configurationWithFont_scale_, font.pointer, scale.value); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithHierarchicalColor: + static UIImageSymbolConfiguration configurationWithHierarchicalColor_( + UIColor hierarchicalColor) { + final _ret = _objc_msgSend_349(_class_UIImageSymbolConfiguration, + _sel_configurationWithHierarchicalColor_, hierarchicalColor.pointer); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithPaletteColors: + static UIImageSymbolConfiguration configurationWithPaletteColors_( + objc.NSArray paletteColors) { + final _ret = _objc_msgSend_350(_class_UIImageSymbolConfiguration, + _sel_configurationWithPaletteColors_, paletteColors.pointer); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationPreferringMulticolor + static UIImageSymbolConfiguration configurationPreferringMulticolor() { + final _ret = _objc_msgSend_18(_class_UIImageSymbolConfiguration, + _sel_configurationPreferringMulticolor); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationPreferringMonochrome + static UIImageSymbolConfiguration configurationPreferringMonochrome() { + final _ret = _objc_msgSend_18(_class_UIImageSymbolConfiguration, + _sel_configurationPreferringMonochrome); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithoutTextStyle + UIImageSymbolConfiguration configurationWithoutTextStyle() { + final _ret = + _objc_msgSend_18(this.pointer, _sel_configurationWithoutTextStyle); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithoutScale + UIImageSymbolConfiguration configurationWithoutScale() { + final _ret = _objc_msgSend_18(this.pointer, _sel_configurationWithoutScale); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithoutWeight + UIImageSymbolConfiguration configurationWithoutWeight() { + final _ret = + _objc_msgSend_18(this.pointer, _sel_configurationWithoutWeight); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithoutPointSizeAndWeight + UIImageSymbolConfiguration configurationWithoutPointSizeAndWeight() { + final _ret = _objc_msgSend_18( + this.pointer, _sel_configurationWithoutPointSizeAndWeight); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// isEqualToConfiguration: + bool isEqualToConfiguration_(UIImageSymbolConfiguration? otherConfiguration) { + return _objc_msgSend_351(this.pointer, _sel_isEqualToConfiguration_, + otherConfiguration?.pointer ?? ffi.nullptr); + } + + /// new + static UIImageSymbolConfiguration new1() { + final _ret = _objc_msgSend_18(_class_UIImageSymbolConfiguration, _sel_new); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: false, release: true); + } + + /// init + UIImageSymbolConfiguration init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithTraitCollection: + static UIImageSymbolConfiguration configurationWithTraitCollection_( + UITraitCollection? traitCollection) { + final _ret = _objc_msgSend_167( + _class_UIImageSymbolConfiguration, + _sel_configurationWithTraitCollection_, + traitCollection?.pointer ?? ffi.nullptr); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationWithLocale: + static UIImageSymbolConfiguration configurationWithLocale_( + objc.NSLocale? locale) { + final _ret = _objc_msgSend_169(_class_UIImageSymbolConfiguration, + _sel_configurationWithLocale_, locale?.pointer ?? ffi.nullptr); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// configurationByApplyingConfiguration: + UIImageSymbolConfiguration configurationByApplyingConfiguration_( + UIImageConfiguration? otherConfiguration) { + final _ret = _objc_msgSend_170( + this.pointer, + _sel_configurationByApplyingConfiguration_, + otherConfiguration?.pointer ?? ffi.nullptr); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// allocWithZone: + static UIImageSymbolConfiguration allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIImageSymbolConfiguration, _sel_allocWithZone_, zone); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIImageSymbolConfiguration alloc() { + final _ret = + _objc_msgSend_18(_class_UIImageSymbolConfiguration, _sel_alloc); + return UIImageSymbolConfiguration.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIImageSymbolConfiguration = + objc.getClass("UIImageSymbolConfiguration"); +late final _sel_unspecifiedConfiguration = + objc.registerName("unspecifiedConfiguration"); +final _objc_msgSend_310 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIImageSymbolScale { + UIImageSymbolScaleDefault(-1), + UIImageSymbolScaleUnspecified(0), + UIImageSymbolScaleSmall(1), + UIImageSymbolScaleMedium(2), + UIImageSymbolScaleLarge(3); + + final int value; + const UIImageSymbolScale(this.value); + + static UIImageSymbolScale fromValue(int value) => switch (value) { + -1 => UIImageSymbolScaleDefault, + 0 => UIImageSymbolScaleUnspecified, + 1 => UIImageSymbolScaleSmall, + 2 => UIImageSymbolScaleMedium, + 3 => UIImageSymbolScaleLarge, + _ => + throw ArgumentError("Unknown value for UIImageSymbolScale: $value"), + }; +} + +late final _sel_configurationWithScale_ = + objc.registerName("configurationWithScale:"); +final _objc_msgSend_311 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_configurationWithPointSize_ = + objc.registerName("configurationWithPointSize:"); +final _objc_msgSend_312 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, double)>(); + +enum UIImageSymbolWeight { + UIImageSymbolWeightUnspecified(0), + UIImageSymbolWeightUltraLight(1), + UIImageSymbolWeightThin(2), + UIImageSymbolWeightLight(3), + UIImageSymbolWeightRegular(4), + UIImageSymbolWeightMedium(5), + UIImageSymbolWeightSemibold(6), + UIImageSymbolWeightBold(7), + UIImageSymbolWeightHeavy(8), + UIImageSymbolWeightBlack(9); + + final int value; + const UIImageSymbolWeight(this.value); + + static UIImageSymbolWeight fromValue(int value) => switch (value) { + 0 => UIImageSymbolWeightUnspecified, + 1 => UIImageSymbolWeightUltraLight, + 2 => UIImageSymbolWeightThin, + 3 => UIImageSymbolWeightLight, + 4 => UIImageSymbolWeightRegular, + 5 => UIImageSymbolWeightMedium, + 6 => UIImageSymbolWeightSemibold, + 7 => UIImageSymbolWeightBold, + 8 => UIImageSymbolWeightHeavy, + 9 => UIImageSymbolWeightBlack, + _ => + throw ArgumentError("Unknown value for UIImageSymbolWeight: $value"), + }; +} + +late final _sel_configurationWithWeight_ = + objc.registerName("configurationWithWeight:"); +final _objc_msgSend_313 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_configurationWithPointSize_weight_ = + objc.registerName("configurationWithPointSize:weight:"); +final _objc_msgSend_314 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, double, int)>(); +late final _sel_configurationWithPointSize_weight_scale_ = + objc.registerName("configurationWithPointSize:weight:scale:"); +final _objc_msgSend_315 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong, + ffi.Long)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, double, int, int)>(); +late final _sel_configurationWithTextStyle_ = + objc.registerName("configurationWithTextStyle:"); +late final _sel_configurationWithTextStyle_scale_ = + objc.registerName("configurationWithTextStyle:scale:"); +final _objc_msgSend_316 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Long)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + +/// UIFont +class UIFont extends objc.NSObject { + UIFont._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIFont] that points to the same underlying object as [other]. + UIFont.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIFont] that wraps the given raw object pointer. + UIFont.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIFont]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIFont); + } + + /// preferredFontForTextStyle: + static UIFont preferredFontForTextStyle_(objc.NSString style) { + final _ret = _objc_msgSend_317( + _class_UIFont, _sel_preferredFontForTextStyle_, style.pointer); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// preferredFontForTextStyle:compatibleWithTraitCollection: + static UIFont preferredFontForTextStyle_compatibleWithTraitCollection_( + objc.NSString style, UITraitCollection? traitCollection) { + final _ret = _objc_msgSend_318( + _class_UIFont, + _sel_preferredFontForTextStyle_compatibleWithTraitCollection_, + style.pointer, + traitCollection?.pointer ?? ffi.nullptr); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// fontWithName:size: + static UIFont? fontWithName_size_(objc.NSString fontName, double fontSize) { + final _ret = _objc_msgSend_319( + _class_UIFont, _sel_fontWithName_size_, fontName.pointer, fontSize); + return _ret.address == 0 + ? null + : UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// familyNames + static objc.NSArray getFamilyNames() { + final _ret = _objc_msgSend_14(_class_UIFont, _sel_familyNames); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// fontNamesForFamilyName: + static objc.NSArray fontNamesForFamilyName_(objc.NSString familyName) { + final _ret = _objc_msgSend_320( + _class_UIFont, _sel_fontNamesForFamilyName_, familyName.pointer); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// systemFontOfSize: + static UIFont systemFontOfSize_(double fontSize) { + final _ret = + _objc_msgSend_321(_class_UIFont, _sel_systemFontOfSize_, fontSize); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// boldSystemFontOfSize: + static UIFont boldSystemFontOfSize_(double fontSize) { + final _ret = + _objc_msgSend_321(_class_UIFont, _sel_boldSystemFontOfSize_, fontSize); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// italicSystemFontOfSize: + static UIFont italicSystemFontOfSize_(double fontSize) { + final _ret = _objc_msgSend_321( + _class_UIFont, _sel_italicSystemFontOfSize_, fontSize); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// systemFontOfSize:weight: + static UIFont systemFontOfSize_weight_(double fontSize, double weight) { + final _ret = _objc_msgSend_322( + _class_UIFont, _sel_systemFontOfSize_weight_, fontSize, weight); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// monospacedDigitSystemFontOfSize:weight: + static UIFont monospacedDigitSystemFontOfSize_weight_( + double fontSize, double weight) { + final _ret = _objc_msgSend_322(_class_UIFont, + _sel_monospacedDigitSystemFontOfSize_weight_, fontSize, weight); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// systemFontOfSize:weight:width: + static UIFont systemFontOfSize_weight_width_( + double fontSize, double weight, double width) { + final _ret = _objc_msgSend_323(_class_UIFont, + _sel_systemFontOfSize_weight_width_, fontSize, weight, width); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// monospacedSystemFontOfSize:weight: + static UIFont monospacedSystemFontOfSize_weight_( + double fontSize, double weight) { + final _ret = _objc_msgSend_322(_class_UIFont, + _sel_monospacedSystemFontOfSize_weight_, fontSize, weight); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// familyName + objc.NSString get familyName { + final _ret = _objc_msgSend_77(this.pointer, _sel_familyName); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// fontName + objc.NSString get fontName { + final _ret = _objc_msgSend_77(this.pointer, _sel_fontName); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pointSize + double get pointSize { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_pointSize) + : _objc_msgSend_11(this.pointer, _sel_pointSize); + } + + /// ascender + double get ascender { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_ascender) + : _objc_msgSend_11(this.pointer, _sel_ascender); + } + + /// descender + double get descender { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_descender) + : _objc_msgSend_11(this.pointer, _sel_descender); + } + + /// capHeight + double get capHeight { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_capHeight) + : _objc_msgSend_11(this.pointer, _sel_capHeight); + } + + /// xHeight + double get xHeight { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_xHeight) + : _objc_msgSend_11(this.pointer, _sel_xHeight); + } + + /// lineHeight + double get lineHeight { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_lineHeight) + : _objc_msgSend_11(this.pointer, _sel_lineHeight); + } + + /// leading + double get leading { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_leading) + : _objc_msgSend_11(this.pointer, _sel_leading); + } + + /// fontWithSize: + UIFont fontWithSize_(double fontSize) { + final _ret = _objc_msgSend_321(this.pointer, _sel_fontWithSize_, fontSize); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// fontWithDescriptor:size: + static UIFont fontWithDescriptor_size_( + UIFontDescriptor descriptor, double pointSize) { + final _ret = _objc_msgSend_336(_class_UIFont, _sel_fontWithDescriptor_size_, + descriptor.pointer, pointSize); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptor + UIFontDescriptor get fontDescriptor { + final _ret = _objc_msgSend_337(this.pointer, _sel_fontDescriptor); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIFont init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIFont.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIFont new1() { + final _ret = _objc_msgSend_18(_class_UIFont, _sel_new); + return UIFont.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIFont allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIFont, _sel_allocWithZone_, zone); + return UIFont.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIFont alloc() { + final _ret = _objc_msgSend_18(_class_UIFont, _sel_alloc); + return UIFont.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIFont = objc.getClass("UIFont"); +late final _sel_preferredFontForTextStyle_ = + objc.registerName("preferredFontForTextStyle:"); +final _objc_msgSend_317 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_preferredFontForTextStyle_compatibleWithTraitCollection_ = objc + .registerName("preferredFontForTextStyle:compatibleWithTraitCollection:"); +final _objc_msgSend_318 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_fontWithName_size_ = objc.registerName("fontWithName:size:"); +final _objc_msgSend_319 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double)>(); +late final _sel_familyNames = objc.registerName("familyNames"); +late final _sel_fontNamesForFamilyName_ = + objc.registerName("fontNamesForFamilyName:"); +final _objc_msgSend_320 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_systemFontOfSize_ = objc.registerName("systemFontOfSize:"); +final _objc_msgSend_321 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_boldSystemFontOfSize_ = + objc.registerName("boldSystemFontOfSize:"); +late final _sel_italicSystemFontOfSize_ = + objc.registerName("italicSystemFontOfSize:"); +late final _sel_systemFontOfSize_weight_ = + objc.registerName("systemFontOfSize:weight:"); +final _objc_msgSend_322 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Double, ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double, double)>(); +late final _sel_monospacedDigitSystemFontOfSize_weight_ = + objc.registerName("monospacedDigitSystemFontOfSize:weight:"); +late final _sel_systemFontOfSize_weight_width_ = + objc.registerName("systemFontOfSize:weight:width:"); +final _objc_msgSend_323 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Double, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double, double, double)>(); +late final _sel_monospacedSystemFontOfSize_weight_ = + objc.registerName("monospacedSystemFontOfSize:weight:"); +late final _sel_familyName = objc.registerName("familyName"); +late final _sel_fontName = objc.registerName("fontName"); +late final _sel_pointSize = objc.registerName("pointSize"); +late final _sel_ascender = objc.registerName("ascender"); +late final _sel_descender = objc.registerName("descender"); +late final _sel_capHeight = objc.registerName("capHeight"); +late final _sel_xHeight = objc.registerName("xHeight"); +late final _sel_lineHeight = objc.registerName("lineHeight"); +late final _sel_leading = objc.registerName("leading"); +late final _sel_fontWithSize_ = objc.registerName("fontWithSize:"); + +/// UIFontDescriptor +class UIFontDescriptor extends objc.NSObject { + UIFontDescriptor._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIFontDescriptor] that points to the same underlying object as [other]. + UIFontDescriptor.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIFontDescriptor] that wraps the given raw object pointer. + UIFontDescriptor.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIFontDescriptor]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIFontDescriptor); + } + + /// init + UIFontDescriptor init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIFontDescriptor? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// postscriptName + objc.NSString get postscriptName { + final _ret = _objc_msgSend_77(this.pointer, _sel_postscriptName); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pointSize + double get pointSize { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_pointSize) + : _objc_msgSend_11(this.pointer, _sel_pointSize); + } + + /// matrix + void getMatrix(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_64Stret(stret, this.pointer, _sel_matrix) + : stret.ref = _objc_msgSend_64(this.pointer, _sel_matrix); + } + + /// symbolicTraits + UIFontDescriptorSymbolicTraits get symbolicTraits { + final _ret = _objc_msgSend_324(this.pointer, _sel_symbolicTraits); + return UIFontDescriptorSymbolicTraits.fromValue(_ret); + } + + /// objectForKey: + objc.ObjCObjectBase? objectForKey_(objc.NSString anAttribute) { + final _ret = + _objc_msgSend_57(this.pointer, _sel_objectForKey_, anAttribute.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// fontAttributes + objc.NSDictionary get fontAttributes { + final _ret = _objc_msgSend_266(this.pointer, _sel_fontAttributes); + return objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// matchingFontDescriptorsWithMandatoryKeys: + objc.NSArray matchingFontDescriptorsWithMandatoryKeys_( + objc.ObjCObjectBase? mandatoryKeys) { + final _ret = _objc_msgSend_325( + this.pointer, + _sel_matchingFontDescriptorsWithMandatoryKeys_, + mandatoryKeys?.pointer ?? ffi.nullptr); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorWithFontAttributes: + static UIFontDescriptor fontDescriptorWithFontAttributes_( + objc.NSDictionary attributes) { + final _ret = _objc_msgSend_326(_class_UIFontDescriptor, + _sel_fontDescriptorWithFontAttributes_, attributes.pointer); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorWithName:size: + static UIFontDescriptor fontDescriptorWithName_size_( + objc.NSString fontName, double size) { + final _ret = _objc_msgSend_327(_class_UIFontDescriptor, + _sel_fontDescriptorWithName_size_, fontName.pointer, size); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorWithName:matrix: + static UIFontDescriptor fontDescriptorWithName_matrix_( + objc.NSString fontName, CGAffineTransform matrix) { + final _ret = _objc_msgSend_328(_class_UIFontDescriptor, + _sel_fontDescriptorWithName_matrix_, fontName.pointer, matrix); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// preferredFontDescriptorWithTextStyle: + static UIFontDescriptor preferredFontDescriptorWithTextStyle_( + objc.NSString style) { + final _ret = _objc_msgSend_329(_class_UIFontDescriptor, + _sel_preferredFontDescriptorWithTextStyle_, style.pointer); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// preferredFontDescriptorWithTextStyle:compatibleWithTraitCollection: + static UIFontDescriptor + preferredFontDescriptorWithTextStyle_compatibleWithTraitCollection_( + objc.NSString style, UITraitCollection? traitCollection) { + final _ret = _objc_msgSend_330( + _class_UIFontDescriptor, + _sel_preferredFontDescriptorWithTextStyle_compatibleWithTraitCollection_, + style.pointer, + traitCollection?.pointer ?? ffi.nullptr); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithFontAttributes: + UIFontDescriptor initWithFontAttributes_(objc.NSDictionary attributes) { + final _ret = _objc_msgSend_331( + this.pointer, _sel_initWithFontAttributes_, attributes.pointer); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorByAddingAttributes: + UIFontDescriptor fontDescriptorByAddingAttributes_( + objc.NSDictionary attributes) { + final _ret = _objc_msgSend_326(this.pointer, + _sel_fontDescriptorByAddingAttributes_, attributes.pointer); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorWithSize: + UIFontDescriptor fontDescriptorWithSize_(double newPointSize) { + final _ret = _objc_msgSend_332( + this.pointer, _sel_fontDescriptorWithSize_, newPointSize); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorWithMatrix: + UIFontDescriptor fontDescriptorWithMatrix_(CGAffineTransform matrix) { + final _ret = + _objc_msgSend_333(this.pointer, _sel_fontDescriptorWithMatrix_, matrix); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorWithFace: + UIFontDescriptor fontDescriptorWithFace_(objc.NSString newFace) { + final _ret = _objc_msgSend_329( + this.pointer, _sel_fontDescriptorWithFace_, newFace.pointer); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorWithFamily: + UIFontDescriptor fontDescriptorWithFamily_(objc.NSString newFamily) { + final _ret = _objc_msgSend_329( + this.pointer, _sel_fontDescriptorWithFamily_, newFamily.pointer); + return UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorWithSymbolicTraits: + UIFontDescriptor? fontDescriptorWithSymbolicTraits_( + UIFontDescriptorSymbolicTraits symbolicTraits) { + final _ret = _objc_msgSend_334(this.pointer, + _sel_fontDescriptorWithSymbolicTraits_, symbolicTraits.value); + return _ret.address == 0 + ? null + : UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// fontDescriptorWithDesign: + UIFontDescriptor? fontDescriptorWithDesign_(objc.NSString design) { + final _ret = _objc_msgSend_335( + this.pointer, _sel_fontDescriptorWithDesign_, design.pointer); + return _ret.address == 0 + ? null + : UIFontDescriptor.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIFontDescriptor new1() { + final _ret = _objc_msgSend_18(_class_UIFontDescriptor, _sel_new); + return UIFontDescriptor.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIFontDescriptor allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIFontDescriptor, _sel_allocWithZone_, zone); + return UIFontDescriptor.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIFontDescriptor alloc() { + final _ret = _objc_msgSend_18(_class_UIFontDescriptor, _sel_alloc); + return UIFontDescriptor.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIFontDescriptor = objc.getClass("UIFontDescriptor"); +late final _sel_postscriptName = objc.registerName("postscriptName"); +late final _sel_matrix = objc.registerName("matrix"); + +enum UIFontDescriptorSymbolicTraits { + UIFontDescriptorTraitItalic(1), + UIFontDescriptorTraitBold(2), + UIFontDescriptorTraitExpanded(32), + UIFontDescriptorTraitCondensed(64), + UIFontDescriptorTraitMonoSpace(1024), + UIFontDescriptorTraitVertical(2048), + UIFontDescriptorTraitUIOptimized(4096), + UIFontDescriptorTraitTightLeading(32768), + UIFontDescriptorTraitLooseLeading(65536), + UIFontDescriptorClassMask(-268435456), + UIFontDescriptorClassUnknown(0), + UIFontDescriptorClassOldStyleSerifs(268435456), + UIFontDescriptorClassTransitionalSerifs(536870912), + UIFontDescriptorClassModernSerifs(805306368), + UIFontDescriptorClassClarendonSerifs(1073741824), + UIFontDescriptorClassSlabSerifs(1342177280), + UIFontDescriptorClassFreeformSerifs(1879048192), + UIFontDescriptorClassSansSerif(-2147483648), + UIFontDescriptorClassOrnamentals(-1879048192), + UIFontDescriptorClassScripts(-1610612736), + UIFontDescriptorClassSymbolic(-1073741824); + + final int value; + const UIFontDescriptorSymbolicTraits(this.value); + + static UIFontDescriptorSymbolicTraits fromValue(int value) => switch (value) { + 1 => UIFontDescriptorTraitItalic, + 2 => UIFontDescriptorTraitBold, + 32 => UIFontDescriptorTraitExpanded, + 64 => UIFontDescriptorTraitCondensed, + 1024 => UIFontDescriptorTraitMonoSpace, + 2048 => UIFontDescriptorTraitVertical, + 4096 => UIFontDescriptorTraitUIOptimized, + 32768 => UIFontDescriptorTraitTightLeading, + 65536 => UIFontDescriptorTraitLooseLeading, + -268435456 => UIFontDescriptorClassMask, + 0 => UIFontDescriptorClassUnknown, + 268435456 => UIFontDescriptorClassOldStyleSerifs, + 536870912 => UIFontDescriptorClassTransitionalSerifs, + 805306368 => UIFontDescriptorClassModernSerifs, + 1073741824 => UIFontDescriptorClassClarendonSerifs, + 1342177280 => UIFontDescriptorClassSlabSerifs, + 1879048192 => UIFontDescriptorClassFreeformSerifs, + -2147483648 => UIFontDescriptorClassSansSerif, + -1879048192 => UIFontDescriptorClassOrnamentals, + -1610612736 => UIFontDescriptorClassScripts, + -1073741824 => UIFontDescriptorClassSymbolic, + _ => throw ArgumentError( + "Unknown value for UIFontDescriptorSymbolicTraits: $value"), + }; +} + +late final _sel_symbolicTraits = objc.registerName("symbolicTraits"); +final _objc_msgSend_324 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Uint32 Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_objectForKey_ = objc.registerName("objectForKey:"); +late final _sel_fontAttributes = objc.registerName("fontAttributes"); +late final _sel_matchingFontDescriptorsWithMandatoryKeys_ = + objc.registerName("matchingFontDescriptorsWithMandatoryKeys:"); +final _objc_msgSend_325 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_fontDescriptorWithFontAttributes_ = + objc.registerName("fontDescriptorWithFontAttributes:"); +final _objc_msgSend_326 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_fontDescriptorWithName_size_ = + objc.registerName("fontDescriptorWithName:size:"); +final _objc_msgSend_327 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double)>(); +late final _sel_fontDescriptorWithName_matrix_ = + objc.registerName("fontDescriptorWithName:matrix:"); +final _objc_msgSend_328 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGAffineTransform)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGAffineTransform)>(); +late final _sel_preferredFontDescriptorWithTextStyle_ = + objc.registerName("preferredFontDescriptorWithTextStyle:"); +final _objc_msgSend_329 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_preferredFontDescriptorWithTextStyle_compatibleWithTraitCollection_ = + objc.registerName( + "preferredFontDescriptorWithTextStyle:compatibleWithTraitCollection:"); +final _objc_msgSend_330 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithFontAttributes_ = + objc.registerName("initWithFontAttributes:"); +final _objc_msgSend_331 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_fontDescriptorByAddingAttributes_ = + objc.registerName("fontDescriptorByAddingAttributes:"); +late final _sel_fontDescriptorWithSize_ = + objc.registerName("fontDescriptorWithSize:"); +final _objc_msgSend_332 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_fontDescriptorWithMatrix_ = + objc.registerName("fontDescriptorWithMatrix:"); +final _objc_msgSend_333 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGAffineTransform)>(); +late final _sel_fontDescriptorWithFace_ = + objc.registerName("fontDescriptorWithFace:"); +late final _sel_fontDescriptorWithFamily_ = + objc.registerName("fontDescriptorWithFamily:"); +late final _sel_fontDescriptorWithSymbolicTraits_ = + objc.registerName("fontDescriptorWithSymbolicTraits:"); +final _objc_msgSend_334 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Uint32)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_fontDescriptorWithDesign_ = + objc.registerName("fontDescriptorWithDesign:"); +final _objc_msgSend_335 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_fontWithDescriptor_size_ = + objc.registerName("fontWithDescriptor:size:"); +final _objc_msgSend_336 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double)>(); +late final _sel_fontDescriptor = objc.registerName("fontDescriptor"); +final _objc_msgSend_337 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_configurationWithFont_ = + objc.registerName("configurationWithFont:"); +final _objc_msgSend_338 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_configurationWithFont_scale_ = + objc.registerName("configurationWithFont:scale:"); +final _objc_msgSend_339 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Long)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + +/// UIColor +class UIColor extends objc.NSObject { + UIColor._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIColor] that points to the same underlying object as [other]. + UIColor.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIColor] that wraps the given raw object pointer. + UIColor.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIColor]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIColor); + } + + /// colorWithWhite:alpha: + static UIColor colorWithWhite_alpha_(double white, double alpha) { + final _ret = _objc_msgSend_340( + _class_UIColor, _sel_colorWithWhite_alpha_, white, alpha); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithHue:saturation:brightness:alpha: + static UIColor colorWithHue_saturation_brightness_alpha_( + double hue, double saturation, double brightness, double alpha) { + final _ret = _objc_msgSend_341( + _class_UIColor, + _sel_colorWithHue_saturation_brightness_alpha_, + hue, + saturation, + brightness, + alpha); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithRed:green:blue:alpha: + static UIColor colorWithRed_green_blue_alpha_( + double red, double green, double blue, double alpha) { + final _ret = _objc_msgSend_341(_class_UIColor, + _sel_colorWithRed_green_blue_alpha_, red, green, blue, alpha); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithDisplayP3Red:green:blue:alpha: + static UIColor colorWithDisplayP3Red_green_blue_alpha_( + double displayP3Red, double green, double blue, double alpha) { + final _ret = _objc_msgSend_341( + _class_UIColor, + _sel_colorWithDisplayP3Red_green_blue_alpha_, + displayP3Red, + green, + blue, + alpha); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithCGColor: + static UIColor colorWithCGColor_(ffi.Pointer cgColor) { + final _ret = + _objc_msgSend_342(_class_UIColor, _sel_colorWithCGColor_, cgColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithPatternImage: + static UIColor colorWithPatternImage_(UIImage image) { + final _ret = _objc_msgSend_343( + _class_UIColor, _sel_colorWithPatternImage_, image.pointer); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// colorWithCIColor: + static UIColor colorWithCIColor_(CIColor ciColor) { + final _ret = _objc_msgSend_344( + _class_UIColor, _sel_colorWithCIColor_, ciColor.pointer); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithWhite:alpha: + UIColor initWithWhite_alpha_(double white, double alpha) { + final _ret = _objc_msgSend_340( + this.pointer, _sel_initWithWhite_alpha_, white, alpha); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithHue:saturation:brightness:alpha: + UIColor initWithHue_saturation_brightness_alpha_( + double hue, double saturation, double brightness, double alpha) { + final _ret = _objc_msgSend_341( + this.pointer, + _sel_initWithHue_saturation_brightness_alpha_, + hue, + saturation, + brightness, + alpha); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithRed:green:blue:alpha: + UIColor initWithRed_green_blue_alpha_( + double red, double green, double blue, double alpha) { + final _ret = _objc_msgSend_341(this.pointer, + _sel_initWithRed_green_blue_alpha_, red, green, blue, alpha); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithDisplayP3Red:green:blue:alpha: + UIColor initWithDisplayP3Red_green_blue_alpha_( + double displayP3Red, double green, double blue, double alpha) { + final _ret = _objc_msgSend_341( + this.pointer, + _sel_initWithDisplayP3Red_green_blue_alpha_, + displayP3Red, + green, + blue, + alpha); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCGColor: + UIColor initWithCGColor_(ffi.Pointer cgColor) { + final _ret = + _objc_msgSend_342(this.pointer, _sel_initWithCGColor_, cgColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithPatternImage: + UIColor initWithPatternImage_(UIImage image) { + final _ret = _objc_msgSend_343( + this.pointer, _sel_initWithPatternImage_, image.pointer); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCIColor: + UIColor initWithCIColor_(CIColor ciColor) { + final _ret = + _objc_msgSend_344(this.pointer, _sel_initWithCIColor_, ciColor.pointer); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// blackColor + static UIColor getBlackColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_blackColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// darkGrayColor + static UIColor getDarkGrayColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_darkGrayColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// lightGrayColor + static UIColor getLightGrayColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_lightGrayColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// whiteColor + static UIColor getWhiteColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_whiteColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// grayColor + static UIColor getGrayColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_grayColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// redColor + static UIColor getRedColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_redColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// greenColor + static UIColor getGreenColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_greenColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// blueColor + static UIColor getBlueColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_blueColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// cyanColor + static UIColor getCyanColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_cyanColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// yellowColor + static UIColor getYellowColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_yellowColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// magentaColor + static UIColor getMagentaColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_magentaColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// orangeColor + static UIColor getOrangeColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_orangeColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// purpleColor + static UIColor getPurpleColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_purpleColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// brownColor + static UIColor getBrownColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_brownColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// clearColor + static UIColor getClearColor() { + final _ret = _objc_msgSend_345(_class_UIColor, _sel_clearColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// set + void set1() { + _objc_msgSend_4(this.pointer, _sel_set); + } + + /// setFill + void setFill() { + _objc_msgSend_4(this.pointer, _sel_setFill); + } + + /// setStroke + void setStroke() { + _objc_msgSend_4(this.pointer, _sel_setStroke); + } + + /// getWhite:alpha: + bool getWhite_alpha_( + ffi.Pointer white, ffi.Pointer alpha) { + return _objc_msgSend_346(this.pointer, _sel_getWhite_alpha_, white, alpha); + } + + /// getHue:saturation:brightness:alpha: + bool getHue_saturation_brightness_alpha_( + ffi.Pointer hue, + ffi.Pointer saturation, + ffi.Pointer brightness, + ffi.Pointer alpha) { + return _objc_msgSend_347( + this.pointer, + _sel_getHue_saturation_brightness_alpha_, + hue, + saturation, + brightness, + alpha); + } + + /// getRed:green:blue:alpha: + bool getRed_green_blue_alpha_( + ffi.Pointer red, + ffi.Pointer green, + ffi.Pointer blue, + ffi.Pointer alpha) { + return _objc_msgSend_347( + this.pointer, _sel_getRed_green_blue_alpha_, red, green, blue, alpha); + } + + /// colorWithAlphaComponent: + UIColor colorWithAlphaComponent_(double alpha) { + final _ret = + _objc_msgSend_348(this.pointer, _sel_colorWithAlphaComponent_, alpha); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// CGColor + ffi.Pointer get CGColor1 { + return _objc_msgSend_85(this.pointer, _sel_CGColor); + } + + /// CIColor + CIColor get CIColor1 { + final _ret = _objc_msgSend_232(this.pointer, _sel_CIColor); + return CIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIColor init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIColor new1() { + final _ret = _objc_msgSend_18(_class_UIColor, _sel_new); + return UIColor.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIColor allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIColor, _sel_allocWithZone_, zone); + return UIColor.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIColor alloc() { + final _ret = _objc_msgSend_18(_class_UIColor, _sel_alloc); + return UIColor.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIColor = objc.getClass("UIColor"); +late final _sel_colorWithWhite_alpha_ = + objc.registerName("colorWithWhite:alpha:"); +final _objc_msgSend_340 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Double, ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double, double)>(); +late final _sel_colorWithHue_saturation_brightness_alpha_ = + objc.registerName("colorWithHue:saturation:brightness:alpha:"); +final _objc_msgSend_341 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Double, + ffi.Double, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double, double, double, double)>(); +late final _sel_colorWithDisplayP3Red_green_blue_alpha_ = + objc.registerName("colorWithDisplayP3Red:green:blue:alpha:"); +final _objc_msgSend_342 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_colorWithPatternImage_ = + objc.registerName("colorWithPatternImage:"); +final _objc_msgSend_343 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_colorWithCIColor_ = objc.registerName("colorWithCIColor:"); +final _objc_msgSend_344 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithWhite_alpha_ = + objc.registerName("initWithWhite:alpha:"); +late final _sel_initWithHue_saturation_brightness_alpha_ = + objc.registerName("initWithHue:saturation:brightness:alpha:"); +late final _sel_initWithDisplayP3Red_green_blue_alpha_ = + objc.registerName("initWithDisplayP3Red:green:blue:alpha:"); +late final _sel_initWithPatternImage_ = + objc.registerName("initWithPatternImage:"); +late final _sel_initWithCIColor_ = objc.registerName("initWithCIColor:"); +final _objc_msgSend_345 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_darkGrayColor = objc.registerName("darkGrayColor"); +late final _sel_lightGrayColor = objc.registerName("lightGrayColor"); +late final _sel_orangeColor = objc.registerName("orangeColor"); +late final _sel_purpleColor = objc.registerName("purpleColor"); +late final _sel_brownColor = objc.registerName("brownColor"); +late final _sel_set = objc.registerName("set"); +late final _sel_setFill = objc.registerName("setFill"); +late final _sel_setStroke = objc.registerName("setStroke"); +late final _sel_getWhite_alpha_ = objc.registerName("getWhite:alpha:"); +final _objc_msgSend_346 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_getHue_saturation_brightness_alpha_ = + objc.registerName("getHue:saturation:brightness:alpha:"); +final _objc_msgSend_347 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_getRed_green_blue_alpha_ = + objc.registerName("getRed:green:blue:alpha:"); +late final _sel_colorWithAlphaComponent_ = + objc.registerName("colorWithAlphaComponent:"); +final _objc_msgSend_348 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_CGColor = objc.registerName("CGColor"); +late final _sel_CIColor = objc.registerName("CIColor"); +late final _sel_configurationWithHierarchicalColor_ = + objc.registerName("configurationWithHierarchicalColor:"); +final _objc_msgSend_349 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_configurationWithPaletteColors_ = + objc.registerName("configurationWithPaletteColors:"); +final _objc_msgSend_350 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_configurationPreferringMulticolor = + objc.registerName("configurationPreferringMulticolor"); +late final _sel_configurationPreferringMonochrome = + objc.registerName("configurationPreferringMonochrome"); +late final _sel_configurationWithoutTextStyle = + objc.registerName("configurationWithoutTextStyle"); +late final _sel_configurationWithoutScale = + objc.registerName("configurationWithoutScale"); +late final _sel_configurationWithoutWeight = + objc.registerName("configurationWithoutWeight"); +late final _sel_configurationWithoutPointSizeAndWeight = + objc.registerName("configurationWithoutPointSizeAndWeight"); +late final _sel_isEqualToConfiguration_ = + objc.registerName("isEqualToConfiguration:"); +final _objc_msgSend_351 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_symbolConfiguration = objc.registerName("symbolConfiguration"); +final _objc_msgSend_352 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageByApplyingSymbolConfiguration_ = + objc.registerName("imageByApplyingSymbolConfiguration:"); +final _objc_msgSend_353 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithTintColor_ = objc.registerName("imageWithTintColor:"); +final _objc_msgSend_354 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageWithTintColor_renderingMode_ = + objc.registerName("imageWithTintColor:renderingMode:"); +final _objc_msgSend_355 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_imageByPreparingForDisplay = + objc.registerName("imageByPreparingForDisplay"); +final _objc_msgSend_356 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +void _ObjCBlock_ffiVoid_UIImage_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_UIImage_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_UIImage extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_UIImage._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_UIImage castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_UIImage._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_UIImage.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_UIImage_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_UIImage.fromFunction(void Function(UIImage?) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_UIImage_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0.address == 0 + ? null + : UIImage.castFromPointer(arg0, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_UIImage.listener(void Function(UIImage?) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_UIImage(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_UIImage_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn(arg0.address == 0 + ? null + : UIImage.castFromPointer(arg0, + retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(UIImage? arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function( + ffi.Pointer, ffi.Pointer)>()( + pointer, arg0?.pointer ?? ffi.nullptr); +} + +late final _sel_prepareForDisplayWithCompletionHandler_ = + objc.registerName("prepareForDisplayWithCompletionHandler:"); +final _objc_msgSend_357 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_imageByPreparingThumbnailOfSize_ = + objc.registerName("imageByPreparingThumbnailOfSize:"); +final _objc_msgSend_358 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGSize)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGSize)>(); +late final _sel_prepareThumbnailOfSize_completionHandler_ = + objc.registerName("prepareThumbnailOfSize:completionHandler:"); +final _objc_msgSend_359 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + CGSize, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + CGSize, + ffi.Pointer)>(); +late final _sel_isHighDynamicRange = objc.registerName("isHighDynamicRange"); +late final _sel_imageRestrictedToStandardDynamicRange = + objc.registerName("imageRestrictedToStandardDynamicRange"); +late final _sel_image = objc.registerName("image"); +late final _sel_setImage_ = objc.registerName("setImage:"); +final _objc_msgSend_360 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_discoverabilityTitle = + objc.registerName("discoverabilityTitle"); +late final _sel_setDiscoverabilityTitle_ = + objc.registerName("setDiscoverabilityTitle:"); +late final _sel_action = objc.registerName("action"); +final _objc_msgSend_361 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_propertyList = objc.registerName("propertyList"); + +enum UIMenuElementAttributes { + UIMenuElementAttributesDisabled(1), + UIMenuElementAttributesDestructive(2), + UIMenuElementAttributesHidden(4), + UIMenuElementAttributesKeepsMenuPresented(8); + + final int value; + const UIMenuElementAttributes(this.value); + + static UIMenuElementAttributes fromValue(int value) => switch (value) { + 1 => UIMenuElementAttributesDisabled, + 2 => UIMenuElementAttributesDestructive, + 4 => UIMenuElementAttributesHidden, + 8 => UIMenuElementAttributesKeepsMenuPresented, + _ => throw ArgumentError( + "Unknown value for UIMenuElementAttributes: $value"), + }; +} + +late final _sel_attributes = objc.registerName("attributes"); +final _objc_msgSend_362 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAttributes_ = objc.registerName("setAttributes:"); +final _objc_msgSend_363 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +enum UIMenuElementState { + UIMenuElementStateOff(0), + UIMenuElementStateOn(1), + UIMenuElementStateMixed(2); + + final int value; + const UIMenuElementState(this.value); + + static UIMenuElementState fromValue(int value) => switch (value) { + 0 => UIMenuElementStateOff, + 1 => UIMenuElementStateOn, + 2 => UIMenuElementStateMixed, + _ => + throw ArgumentError("Unknown value for UIMenuElementState: $value"), + }; +} + +final _objc_msgSend_364 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setState_ = objc.registerName("setState:"); +final _objc_msgSend_365 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_alternates = objc.registerName("alternates"); +late final _sel_commandWithTitle_image_action_propertyList_ = + objc.registerName("commandWithTitle:image:action:propertyList:"); +final _objc_msgSend_366 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_commandWithTitle_image_action_propertyList_alternates_ = + objc.registerName("commandWithTitle:image:action:propertyList:alternates:"); +final _objc_msgSend_367 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// UIMenuElement +class UIMenuElement extends objc.NSObject { + UIMenuElement._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIMenuElement] that points to the same underlying object as [other]. + UIMenuElement.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIMenuElement] that wraps the given raw object pointer. + UIMenuElement.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIMenuElement]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIMenuElement); + } + + /// title + objc.NSString get title { + final _ret = _objc_msgSend_77(this.pointer, _sel_title); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// subtitle + objc.NSString? get subtitle { + final _ret = _objc_msgSend_29(this.pointer, _sel_subtitle); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setSubtitle: + set subtitle(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setSubtitle_, value?.pointer ?? ffi.nullptr); + } + + /// image + UIImage? get image { + final _ret = _objc_msgSend_356(this.pointer, _sel_image); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIMenuElement? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIMenuElement.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIMenuElement init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIMenuElement.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIMenuElement new1() { + final _ret = _objc_msgSend_18(_class_UIMenuElement, _sel_new); + return UIMenuElement.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIMenuElement allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIMenuElement, _sel_allocWithZone_, zone); + return UIMenuElement.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIMenuElement alloc() { + final _ret = _objc_msgSend_18(_class_UIMenuElement, _sel_alloc); + return UIMenuElement.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIMenuElement = objc.getClass("UIMenuElement"); +late final _sel_subtitle = objc.registerName("subtitle"); +late final _sel_setSubtitle_ = objc.registerName("setSubtitle:"); +late final _sel_validateCommand_ = objc.registerName("validateCommand:"); +final _objc_msgSend_368 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// NSUndoManager +class NSUndoManager extends objc.NSObject { + NSUndoManager._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSUndoManager] that points to the same underlying object as [other]. + NSUndoManager.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSUndoManager] that wraps the given raw object pointer. + NSUndoManager.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSUndoManager]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSUndoManager); + } + + /// beginUndoGrouping + void beginUndoGrouping() { + _objc_msgSend_4(this.pointer, _sel_beginUndoGrouping); + } + + /// endUndoGrouping + void endUndoGrouping() { + _objc_msgSend_4(this.pointer, _sel_endUndoGrouping); + } + + /// groupingLevel + int get groupingLevel { + return _objc_msgSend_48(this.pointer, _sel_groupingLevel); + } + + /// disableUndoRegistration + void disableUndoRegistration() { + _objc_msgSend_4(this.pointer, _sel_disableUndoRegistration); + } + + /// enableUndoRegistration + void enableUndoRegistration() { + _objc_msgSend_4(this.pointer, _sel_enableUndoRegistration); + } + + /// isUndoRegistrationEnabled + bool get undoRegistrationEnabled { + return _objc_msgSend_5(this.pointer, _sel_isUndoRegistrationEnabled); + } + + /// groupsByEvent + bool get groupsByEvent { + return _objc_msgSend_5(this.pointer, _sel_groupsByEvent); + } + + /// setGroupsByEvent: + set groupsByEvent(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setGroupsByEvent_, value); + } + + /// levelsOfUndo + int get levelsOfUndo { + return _objc_msgSend_42(this.pointer, _sel_levelsOfUndo); + } + + /// setLevelsOfUndo: + set levelsOfUndo(int value) { + return _objc_msgSend_369(this.pointer, _sel_setLevelsOfUndo_, value); + } + + /// runLoopModes + objc.NSArray get runLoopModes { + final _ret = _objc_msgSend_14(this.pointer, _sel_runLoopModes); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// setRunLoopModes: + set runLoopModes(objc.NSArray value) { + return _objc_msgSend_124( + this.pointer, _sel_setRunLoopModes_, value.pointer); + } + + /// undo + void undo() { + _objc_msgSend_4(this.pointer, _sel_undo); + } + + /// redo + void redo() { + _objc_msgSend_4(this.pointer, _sel_redo); + } + + /// undoNestedGroup + void undoNestedGroup() { + _objc_msgSend_4(this.pointer, _sel_undoNestedGroup); + } + + /// canUndo + bool get canUndo { + return _objc_msgSend_5(this.pointer, _sel_canUndo); + } + + /// canRedo + bool get canRedo { + return _objc_msgSend_5(this.pointer, _sel_canRedo); + } + + /// undoCount + int get undoCount { + return _objc_msgSend_42(this.pointer, _sel_undoCount); + } + + /// redoCount + int get redoCount { + return _objc_msgSend_42(this.pointer, _sel_redoCount); + } + + /// isUndoing + bool get undoing { + return _objc_msgSend_5(this.pointer, _sel_isUndoing); + } + + /// isRedoing + bool get redoing { + return _objc_msgSend_5(this.pointer, _sel_isRedoing); + } + + /// removeAllActions + void removeAllActions() { + _objc_msgSend_4(this.pointer, _sel_removeAllActions); + } + + /// removeAllActionsWithTarget: + void removeAllActionsWithTarget_(objc.ObjCObjectBase target) { + _objc_msgSend_134( + this.pointer, _sel_removeAllActionsWithTarget_, target.pointer); + } + + /// registerUndoWithTarget:selector:object: + void registerUndoWithTarget_selector_object_(objc.ObjCObjectBase target, + ffi.Pointer selector, objc.ObjCObjectBase? object) { + _objc_msgSend_370( + this.pointer, + _sel_registerUndoWithTarget_selector_object_, + target.pointer, + selector, + object?.pointer ?? ffi.nullptr); + } + + /// prepareWithInvocationTarget: + objc.ObjCObjectBase prepareWithInvocationTarget_(objc.ObjCObjectBase target) { + final _ret = _objc_msgSend_56( + this.pointer, _sel_prepareWithInvocationTarget_, target.pointer); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// registerUndoWithTarget:handler: + void registerUndoWithTarget_handler_(objc.ObjCObjectBase target, + ObjCBlock_ffiVoid_objcObjCObject undoHandler) { + _objc_msgSend_371(this.pointer, _sel_registerUndoWithTarget_handler_, + target.pointer, undoHandler.pointer); + } + + /// setActionIsDiscardable: + void setActionIsDiscardable_(bool discardable) { + _objc_msgSend_372(this.pointer, _sel_setActionIsDiscardable_, discardable); + } + + /// undoActionIsDiscardable + bool get undoActionIsDiscardable { + return _objc_msgSend_5(this.pointer, _sel_undoActionIsDiscardable); + } + + /// redoActionIsDiscardable + bool get redoActionIsDiscardable { + return _objc_msgSend_5(this.pointer, _sel_redoActionIsDiscardable); + } + + /// undoActionName + objc.NSString get undoActionName { + final _ret = _objc_msgSend_77(this.pointer, _sel_undoActionName); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// redoActionName + objc.NSString get redoActionName { + final _ret = _objc_msgSend_77(this.pointer, _sel_redoActionName); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setActionName: + void setActionName_(objc.NSString actionName) { + _objc_msgSend_101(this.pointer, _sel_setActionName_, actionName.pointer); + } + + /// undoMenuItemTitle + objc.NSString get undoMenuItemTitle { + final _ret = _objc_msgSend_77(this.pointer, _sel_undoMenuItemTitle); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// redoMenuItemTitle + objc.NSString get redoMenuItemTitle { + final _ret = _objc_msgSend_77(this.pointer, _sel_redoMenuItemTitle); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// undoMenuTitleForUndoActionName: + objc.NSString undoMenuTitleForUndoActionName_(objc.NSString actionName) { + final _ret = _objc_msgSend_373( + this.pointer, _sel_undoMenuTitleForUndoActionName_, actionName.pointer); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// redoMenuTitleForUndoActionName: + objc.NSString redoMenuTitleForUndoActionName_(objc.NSString actionName) { + final _ret = _objc_msgSend_373( + this.pointer, _sel_redoMenuTitleForUndoActionName_, actionName.pointer); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSUndoManager init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSUndoManager.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSUndoManager new1() { + final _ret = _objc_msgSend_18(_class_NSUndoManager, _sel_new); + return NSUndoManager.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSUndoManager allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSUndoManager, _sel_allocWithZone_, zone); + return NSUndoManager.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSUndoManager alloc() { + final _ret = _objc_msgSend_18(_class_NSUndoManager, _sel_alloc); + return NSUndoManager.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSUndoManager = objc.getClass("NSUndoManager"); +late final _sel_beginUndoGrouping = objc.registerName("beginUndoGrouping"); +late final _sel_endUndoGrouping = objc.registerName("endUndoGrouping"); +late final _sel_groupingLevel = objc.registerName("groupingLevel"); +late final _sel_disableUndoRegistration = + objc.registerName("disableUndoRegistration"); +late final _sel_enableUndoRegistration = + objc.registerName("enableUndoRegistration"); +late final _sel_isUndoRegistrationEnabled = + objc.registerName("isUndoRegistrationEnabled"); +late final _sel_groupsByEvent = objc.registerName("groupsByEvent"); +late final _sel_setGroupsByEvent_ = objc.registerName("setGroupsByEvent:"); +late final _sel_levelsOfUndo = objc.registerName("levelsOfUndo"); +late final _sel_setLevelsOfUndo_ = objc.registerName("setLevelsOfUndo:"); +final _objc_msgSend_369 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_runLoopModes = objc.registerName("runLoopModes"); +late final _sel_setRunLoopModes_ = objc.registerName("setRunLoopModes:"); +late final _sel_undo = objc.registerName("undo"); +late final _sel_redo = objc.registerName("redo"); +late final _sel_undoNestedGroup = objc.registerName("undoNestedGroup"); +late final _sel_canUndo = objc.registerName("canUndo"); +late final _sel_canRedo = objc.registerName("canRedo"); +late final _sel_undoCount = objc.registerName("undoCount"); +late final _sel_redoCount = objc.registerName("redoCount"); +late final _sel_isUndoing = objc.registerName("isUndoing"); +late final _sel_isRedoing = objc.registerName("isRedoing"); +late final _sel_removeAllActions = objc.registerName("removeAllActions"); +late final _sel_removeAllActionsWithTarget_ = + objc.registerName("removeAllActionsWithTarget:"); +late final _sel_registerUndoWithTarget_selector_object_ = + objc.registerName("registerUndoWithTarget:selector:object:"); +final _objc_msgSend_370 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_prepareWithInvocationTarget_ = + objc.registerName("prepareWithInvocationTarget:"); +void _ObjCBlock_ffiVoid_objcObjCObject_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_objcObjCObject_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_objcObjCObject extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_objcObjCObject._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_objcObjCObject castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_objcObjCObject._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_objcObjCObject.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_objcObjCObject_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_objcObjCObject.fromFunction( + void Function(objc.ObjCObjectBase) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_objcObjCObject_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => + fn(objc.ObjCObjectBase(arg0, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_objcObjCObject.listener( + void Function(objc.ObjCObjectBase) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_objcObjCObject( + objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_objcObjCObject_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn( + objc.ObjCObjectBase(arg0, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(objc.ObjCObjectBase arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0.pointer); +} + +late final _sel_registerUndoWithTarget_handler_ = + objc.registerName("registerUndoWithTarget:handler:"); +final _objc_msgSend_371 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_setActionIsDiscardable_ = + objc.registerName("setActionIsDiscardable:"); +final _objc_msgSend_372 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, bool)>(); +late final _sel_undoActionIsDiscardable = + objc.registerName("undoActionIsDiscardable"); +late final _sel_redoActionIsDiscardable = + objc.registerName("redoActionIsDiscardable"); +late final _sel_undoActionName = objc.registerName("undoActionName"); +late final _sel_redoActionName = objc.registerName("redoActionName"); +late final _sel_setActionName_ = objc.registerName("setActionName:"); +late final _sel_undoMenuItemTitle = objc.registerName("undoMenuItemTitle"); +late final _sel_redoMenuItemTitle = objc.registerName("redoMenuItemTitle"); +late final _sel_undoMenuTitleForUndoActionName_ = + objc.registerName("undoMenuTitleForUndoActionName:"); +final _objc_msgSend_373 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_redoMenuTitleForUndoActionName_ = + objc.registerName("redoMenuTitleForUndoActionName:"); +late final _sel_undoManager = objc.registerName("undoManager"); +final _objc_msgSend_374 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIEditingInteractionConfiguration { + UIEditingInteractionConfigurationNone(0), + UIEditingInteractionConfigurationDefault(1); + + final int value; + const UIEditingInteractionConfiguration(this.value); + + static UIEditingInteractionConfiguration fromValue(int value) => + switch (value) { + 0 => UIEditingInteractionConfigurationNone, + 1 => UIEditingInteractionConfigurationDefault, + _ => throw ArgumentError( + "Unknown value for UIEditingInteractionConfiguration: $value"), + }; +} + +late final _sel_editingInteractionConfiguration = + objc.registerName("editingInteractionConfiguration"); +final _objc_msgSend_375 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_focusedView = objc.registerName("focusedView"); +late final _sel_supportsFocus = objc.registerName("supportsFocus"); +late final _sel_applicationFrame = objc.registerName("applicationFrame"); +late final _sel_screen = objc.registerName("screen"); + +enum UIInterfaceOrientation { + UIInterfaceOrientationUnknown(0), + UIInterfaceOrientationPortrait(1), + UIInterfaceOrientationPortraitUpsideDown(2), + UIInterfaceOrientationLandscapeLeft(4), + UIInterfaceOrientationLandscapeRight(3); + + final int value; + const UIInterfaceOrientation(this.value); + + static UIInterfaceOrientation fromValue(int value) => switch (value) { + 0 => UIInterfaceOrientationUnknown, + 1 => UIInterfaceOrientationPortrait, + 2 => UIInterfaceOrientationPortraitUpsideDown, + 4 => UIInterfaceOrientationLandscapeLeft, + 3 => UIInterfaceOrientationLandscapeRight, + _ => throw ArgumentError( + "Unknown value for UIInterfaceOrientation: $value"), + }; +} + +late final _sel_interfaceOrientation = + objc.registerName("interfaceOrientation"); +final _objc_msgSend_376 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UIWindowSceneGeometryPreferences +class UIWindowSceneGeometryPreferences extends objc.NSObject { + UIWindowSceneGeometryPreferences._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIWindowSceneGeometryPreferences] that points to the same underlying object as [other]. + UIWindowSceneGeometryPreferences.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIWindowSceneGeometryPreferences] that wraps the given raw object pointer. + UIWindowSceneGeometryPreferences.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIWindowSceneGeometryPreferences]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, + _class_UIWindowSceneGeometryPreferences); + } + + /// init + UIWindowSceneGeometryPreferences init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIWindowSceneGeometryPreferences.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIWindowSceneGeometryPreferences new1() { + final _ret = + _objc_msgSend_18(_class_UIWindowSceneGeometryPreferences, _sel_new); + return UIWindowSceneGeometryPreferences.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIWindowSceneGeometryPreferences allocWithZone_( + ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIWindowSceneGeometryPreferences, _sel_allocWithZone_, zone); + return UIWindowSceneGeometryPreferences.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIWindowSceneGeometryPreferences alloc() { + final _ret = + _objc_msgSend_18(_class_UIWindowSceneGeometryPreferences, _sel_alloc); + return UIWindowSceneGeometryPreferences.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIWindowSceneGeometryPreferences = + objc.getClass("UIWindowSceneGeometryPreferences"); +void _ObjCBlock_ffiVoid_NSError_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_NSError_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_NSError extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSError._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSError castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSError._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSError.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSError_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSError.fromFunction(void Function(objc.NSError) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSError_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn( + objc.NSError.castFromPointer(arg0, + retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSError.listener(void Function(objc.NSError) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSError(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSError_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn( + objc.NSError.castFromPointer(arg0, + retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(objc.NSError arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0.pointer); +} + +late final _sel_requestGeometryUpdateWithPreferences_errorHandler_ = + objc.registerName("requestGeometryUpdateWithPreferences:errorHandler:"); +final _objc_msgSend_377 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// UIWindowSceneGeometry +class UIWindowSceneGeometry extends objc.NSObject { + UIWindowSceneGeometry._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIWindowSceneGeometry] that points to the same underlying object as [other]. + UIWindowSceneGeometry.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIWindowSceneGeometry] that wraps the given raw object pointer. + UIWindowSceneGeometry.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIWindowSceneGeometry]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIWindowSceneGeometry); + } + + /// init + UIWindowSceneGeometry init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIWindowSceneGeometry.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIWindowSceneGeometry new1() { + final _ret = _objc_msgSend_18(_class_UIWindowSceneGeometry, _sel_new); + return UIWindowSceneGeometry.castFromPointer(_ret, + retain: false, release: true); + } + + /// systemFrame + void getSystemFrame(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_systemFrame) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_systemFrame); + } + + /// interfaceOrientation + UIInterfaceOrientation get interfaceOrientation { + final _ret = _objc_msgSend_376(this.pointer, _sel_interfaceOrientation); + return UIInterfaceOrientation.fromValue(_ret); + } + + /// minimumSize + void getMinimumSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_minimumSize) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_minimumSize); + } + + /// maximumSize + void getMaximumSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_maximumSize) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_maximumSize); + } + + /// resizingRestrictions + UIWindowSceneResizingRestrictions get resizingRestrictions { + final _ret = _objc_msgSend_378(this.pointer, _sel_resizingRestrictions); + return UIWindowSceneResizingRestrictions.fromValue(_ret); + } + + /// allocWithZone: + static UIWindowSceneGeometry allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIWindowSceneGeometry, _sel_allocWithZone_, zone); + return UIWindowSceneGeometry.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIWindowSceneGeometry alloc() { + final _ret = _objc_msgSend_18(_class_UIWindowSceneGeometry, _sel_alloc); + return UIWindowSceneGeometry.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIWindowSceneGeometry = + objc.getClass("UIWindowSceneGeometry"); +late final _sel_systemFrame = objc.registerName("systemFrame"); +late final _sel_minimumSize = objc.registerName("minimumSize"); +late final _sel_maximumSize = objc.registerName("maximumSize"); + +enum UIWindowSceneResizingRestrictions { + UIWindowSceneResizingRestrictionsUnspecified(0), + UIWindowSceneResizingRestrictionsNone(1), + UIWindowSceneResizingRestrictionsUniform(2), + UIWindowSceneResizingRestrictionsFreeform(3); + + final int value; + const UIWindowSceneResizingRestrictions(this.value); + + static UIWindowSceneResizingRestrictions fromValue(int value) => + switch (value) { + 0 => UIWindowSceneResizingRestrictionsUnspecified, + 1 => UIWindowSceneResizingRestrictionsNone, + 2 => UIWindowSceneResizingRestrictionsUniform, + 3 => UIWindowSceneResizingRestrictionsFreeform, + _ => throw ArgumentError( + "Unknown value for UIWindowSceneResizingRestrictions: $value"), + }; +} + +late final _sel_resizingRestrictions = + objc.registerName("resizingRestrictions"); +final _objc_msgSend_378 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_effectiveGeometry = objc.registerName("effectiveGeometry"); +final _objc_msgSend_379 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UISceneSizeRestrictions +class UISceneSizeRestrictions extends objc.NSObject { + UISceneSizeRestrictions._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneSizeRestrictions] that points to the same underlying object as [other]. + UISceneSizeRestrictions.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneSizeRestrictions] that wraps the given raw object pointer. + UISceneSizeRestrictions.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneSizeRestrictions]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UISceneSizeRestrictions); + } + + /// init + UISceneSizeRestrictions init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneSizeRestrictions.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UISceneSizeRestrictions new1() { + final _ret = _objc_msgSend_18(_class_UISceneSizeRestrictions, _sel_new); + return UISceneSizeRestrictions.castFromPointer(_ret, + retain: false, release: true); + } + + /// minimumSize + void getMinimumSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_minimumSize) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_minimumSize); + } + + /// setMinimumSize: + set minimumSize(CGSize value) { + return _objc_msgSend_92(this.pointer, _sel_setMinimumSize_, value); + } + + /// maximumSize + void getMaximumSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_maximumSize) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_maximumSize); + } + + /// setMaximumSize: + set maximumSize(CGSize value) { + return _objc_msgSend_92(this.pointer, _sel_setMaximumSize_, value); + } + + /// allowsFullScreen + bool get allowsFullScreen { + return _objc_msgSend_5(this.pointer, _sel_allowsFullScreen); + } + + /// setAllowsFullScreen: + set allowsFullScreen(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setAllowsFullScreen_, value); + } + + /// allocWithZone: + static UISceneSizeRestrictions allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UISceneSizeRestrictions, _sel_allocWithZone_, zone); + return UISceneSizeRestrictions.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UISceneSizeRestrictions alloc() { + final _ret = _objc_msgSend_18(_class_UISceneSizeRestrictions, _sel_alloc); + return UISceneSizeRestrictions.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UISceneSizeRestrictions = + objc.getClass("UISceneSizeRestrictions"); +late final _sel_setMinimumSize_ = objc.registerName("setMinimumSize:"); +late final _sel_setMaximumSize_ = objc.registerName("setMaximumSize:"); +late final _sel_allowsFullScreen = objc.registerName("allowsFullScreen"); +late final _sel_setAllowsFullScreen_ = + objc.registerName("setAllowsFullScreen:"); +late final _sel_sizeRestrictions = objc.registerName("sizeRestrictions"); +final _objc_msgSend_380 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_windows = objc.registerName("windows"); +late final _sel_keyWindow = objc.registerName("keyWindow"); +final _objc_msgSend_381 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_activityItemsConfigurationSource = + objc.registerName("activityItemsConfigurationSource"); +late final _sel_setActivityItemsConfigurationSource_ = + objc.registerName("setActivityItemsConfigurationSource:"); + +/// UISceneWindowingBehaviors +class UISceneWindowingBehaviors extends objc.NSObject { + UISceneWindowingBehaviors._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneWindowingBehaviors] that points to the same underlying object as [other]. + UISceneWindowingBehaviors.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneWindowingBehaviors] that wraps the given raw object pointer. + UISceneWindowingBehaviors.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneWindowingBehaviors]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UISceneWindowingBehaviors); + } + + /// init + UISceneWindowingBehaviors init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneWindowingBehaviors.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UISceneWindowingBehaviors new1() { + final _ret = _objc_msgSend_18(_class_UISceneWindowingBehaviors, _sel_new); + return UISceneWindowingBehaviors.castFromPointer(_ret, + retain: false, release: true); + } + + /// isClosable + bool get closable { + return _objc_msgSend_5(this.pointer, _sel_isClosable); + } + + /// setClosable: + set closable(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setClosable_, value); + } + + /// isMiniaturizable + bool get miniaturizable { + return _objc_msgSend_5(this.pointer, _sel_isMiniaturizable); + } + + /// setMiniaturizable: + set miniaturizable(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setMiniaturizable_, value); + } + + /// allocWithZone: + static UISceneWindowingBehaviors allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UISceneWindowingBehaviors, _sel_allocWithZone_, zone); + return UISceneWindowingBehaviors.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UISceneWindowingBehaviors alloc() { + final _ret = _objc_msgSend_18(_class_UISceneWindowingBehaviors, _sel_alloc); + return UISceneWindowingBehaviors.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UISceneWindowingBehaviors = + objc.getClass("UISceneWindowingBehaviors"); +late final _sel_isClosable = objc.registerName("isClosable"); +late final _sel_setClosable_ = objc.registerName("setClosable:"); +late final _sel_isMiniaturizable = objc.registerName("isMiniaturizable"); +late final _sel_setMiniaturizable_ = objc.registerName("setMiniaturizable:"); +late final _sel_windowingBehaviors = objc.registerName("windowingBehaviors"); +final _objc_msgSend_382 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isFullScreen = objc.registerName("isFullScreen"); + +/// UIScene +class UIScene extends UIResponder { + UIScene._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIScene] that points to the same underlying object as [other]. + UIScene.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIScene] that wraps the given raw object pointer. + UIScene.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIScene]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIScene); + } + + /// new + static UIScene new1() { + final _ret = _objc_msgSend_18(_class_UIScene, _sel_new); + return UIScene.castFromPointer(_ret, retain: false, release: true); + } + + /// init + UIScene init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIScene.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithSession:connectionOptions: + UIScene initWithSession_connectionOptions_( + UISceneSession session, UISceneConnectionOptions connectionOptions) { + final _ret = _objc_msgSend_539( + this.pointer, + _sel_initWithSession_connectionOptions_, + session.pointer, + connectionOptions.pointer); + return UIScene.castFromPointer(_ret, retain: true, release: true); + } + + /// session + UISceneSession get session { + final _ret = _objc_msgSend_540(this.pointer, _sel_session); + return UISceneSession.castFromPointer(_ret, retain: true, release: true); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// activationState + UISceneActivationState get activationState { + final _ret = _objc_msgSend_541(this.pointer, _sel_activationState); + return UISceneActivationState.fromValue(_ret); + } + + /// openURL:options:completionHandler: + void openURL_options_completionHandler_( + objc.NSURL url, + UISceneOpenExternalURLOptions? options, + ObjCBlock_ffiVoid_bool? completion) { + _objc_msgSend_546( + this.pointer, + _sel_openURL_options_completionHandler_, + url.pointer, + options?.pointer ?? ffi.nullptr, + completion?.pointer ?? ffi.nullptr); + } + + /// title + objc.NSString get title { + final _ret = _objc_msgSend_77(this.pointer, _sel_title); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTitle: + set title(objc.NSString value) { + return _objc_msgSend_78(this.pointer, _sel_setTitle_, value.pointer); + } + + /// subtitle + objc.NSString get subtitle { + final _ret = _objc_msgSend_77(this.pointer, _sel_subtitle); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setSubtitle: + set subtitle(objc.NSString value) { + return _objc_msgSend_78(this.pointer, _sel_setSubtitle_, value.pointer); + } + + /// activationConditions + UISceneActivationConditions get activationConditions { + final _ret = _objc_msgSend_557(this.pointer, _sel_activationConditions); + return UISceneActivationConditions.castFromPointer(_ret, + retain: true, release: true); + } + + /// setActivationConditions: + set activationConditions(UISceneActivationConditions value) { + return _objc_msgSend_558( + this.pointer, _sel_setActivationConditions_, value.pointer); + } + + /// allocWithZone: + static UIScene allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIScene, _sel_allocWithZone_, zone); + return UIScene.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIScene alloc() { + final _ret = _objc_msgSend_18(_class_UIScene, _sel_alloc); + return UIScene.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIScene = objc.getClass("UIScene"); + +/// UISceneSession +class UISceneSession extends objc.NSObject { + UISceneSession._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneSession] that points to the same underlying object as [other]. + UISceneSession.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneSession] that wraps the given raw object pointer. + UISceneSession.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneSession]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UISceneSession); + } + + /// new + static UISceneSession new1() { + final _ret = _objc_msgSend_18(_class_UISceneSession, _sel_new); + return UISceneSession.castFromPointer(_ret, retain: false, release: true); + } + + /// init + UISceneSession init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneSession.castFromPointer(_ret, retain: true, release: true); + } + + /// scene + UIScene? get scene { + final _ret = _objc_msgSend_383(this.pointer, _sel_scene); + return _ret.address == 0 + ? null + : UIScene.castFromPointer(_ret, retain: true, release: true); + } + + /// role + objc.NSString get role { + final _ret = _objc_msgSend_77(this.pointer, _sel_role); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// configuration + UISceneConfiguration get configuration { + final _ret = _objc_msgSend_512(this.pointer, _sel_configuration); + return UISceneConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// persistentIdentifier + objc.NSString get persistentIdentifier { + final _ret = _objc_msgSend_77(this.pointer, _sel_persistentIdentifier); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// stateRestorationActivity + NSUserActivity? get stateRestorationActivity { + final _ret = _objc_msgSend_529(this.pointer, _sel_stateRestorationActivity); + return _ret.address == 0 + ? null + : NSUserActivity.castFromPointer(_ret, retain: true, release: true); + } + + /// setStateRestorationActivity: + set stateRestorationActivity(NSUserActivity? value) { + return _objc_msgSend_530(this.pointer, _sel_setStateRestorationActivity_, + value?.pointer ?? ffi.nullptr); + } + + /// userInfo + objc.NSDictionary? get userInfo { + final _ret = _objc_msgSend_104(this.pointer, _sel_userInfo); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// setUserInfo: + set userInfo(objc.NSDictionary? value) { + return _objc_msgSend_105( + this.pointer, _sel_setUserInfo_, value?.pointer ?? ffi.nullptr); + } + + /// allocWithZone: + static UISceneSession allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UISceneSession, _sel_allocWithZone_, zone); + return UISceneSession.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UISceneSession alloc() { + final _ret = _objc_msgSend_18(_class_UISceneSession, _sel_alloc); + return UISceneSession.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UISceneSession = objc.getClass("UISceneSession"); +late final _sel_scene = objc.registerName("scene"); +final _objc_msgSend_383 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_role = objc.registerName("role"); + +/// UISceneConfiguration +class UISceneConfiguration extends objc.NSObject { + UISceneConfiguration._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneConfiguration] that points to the same underlying object as [other]. + UISceneConfiguration.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneConfiguration] that wraps the given raw object pointer. + UISceneConfiguration.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneConfiguration]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UISceneConfiguration); + } + + /// configurationWithName:sessionRole: + static UISceneConfiguration configurationWithName_sessionRole_( + objc.NSString? name, objc.NSString sessionRole) { + final _ret = _objc_msgSend_384( + _class_UISceneConfiguration, + _sel_configurationWithName_sessionRole_, + name?.pointer ?? ffi.nullptr, + sessionRole.pointer); + return UISceneConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithName:sessionRole: + UISceneConfiguration initWithName_sessionRole_( + objc.NSString? name, objc.NSString sessionRole) { + final _ret = _objc_msgSend_384(this.pointer, _sel_initWithName_sessionRole_, + name?.pointer ?? ffi.nullptr, sessionRole.pointer); + return UISceneConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// name + objc.NSString? get name { + final _ret = _objc_msgSend_29(this.pointer, _sel_name); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// role + objc.NSString get role { + final _ret = _objc_msgSend_77(this.pointer, _sel_role); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// sceneClass + objc.ObjCObjectBase? get sceneClass { + final _ret = _objc_msgSend_2(this.pointer, _sel_sceneClass); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setSceneClass: + set sceneClass(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setSceneClass_, value?.pointer ?? ffi.nullptr); + } + + /// delegateClass + objc.ObjCObjectBase? get delegateClass { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegateClass); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegateClass: + set delegateClass(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegateClass_, value?.pointer ?? ffi.nullptr); + } + + /// storyboard + UIStoryboard? get storyboard { + final _ret = _objc_msgSend_390(this.pointer, _sel_storyboard); + return _ret.address == 0 + ? null + : UIStoryboard.castFromPointer(_ret, retain: true, release: true); + } + + /// setStoryboard: + set storyboard(UIStoryboard? value) { + return _objc_msgSend_511( + this.pointer, _sel_setStoryboard_, value?.pointer ?? ffi.nullptr); + } + + /// init + UISceneConfiguration init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UISceneConfiguration new1() { + final _ret = _objc_msgSend_18(_class_UISceneConfiguration, _sel_new); + return UISceneConfiguration.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UISceneConfiguration allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UISceneConfiguration, _sel_allocWithZone_, zone); + return UISceneConfiguration.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UISceneConfiguration alloc() { + final _ret = _objc_msgSend_18(_class_UISceneConfiguration, _sel_alloc); + return UISceneConfiguration.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UISceneConfiguration = objc.getClass("UISceneConfiguration"); +late final _sel_configurationWithName_sessionRole_ = + objc.registerName("configurationWithName:sessionRole:"); +final _objc_msgSend_384 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithName_sessionRole_ = + objc.registerName("initWithName:sessionRole:"); +late final _sel_sceneClass = objc.registerName("sceneClass"); +late final _sel_setSceneClass_ = objc.registerName("setSceneClass:"); +late final _sel_delegateClass = objc.registerName("delegateClass"); +late final _sel_setDelegateClass_ = objc.registerName("setDelegateClass:"); + +/// UIStoryboard +class UIStoryboard extends objc.NSObject { + UIStoryboard._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIStoryboard] that points to the same underlying object as [other]. + UIStoryboard.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIStoryboard] that wraps the given raw object pointer. + UIStoryboard.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIStoryboard]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIStoryboard); + } + + /// storyboardWithName:bundle: + static UIStoryboard storyboardWithName_bundle_( + objc.NSString name, NSBundle? storyboardBundleOrNil) { + final _ret = _objc_msgSend_385( + _class_UIStoryboard, + _sel_storyboardWithName_bundle_, + name.pointer, + storyboardBundleOrNil?.pointer ?? ffi.nullptr); + return UIStoryboard.castFromPointer(_ret, retain: true, release: true); + } + + /// instantiateInitialViewController + UIViewController? instantiateInitialViewController() { + final _ret = + _objc_msgSend_404(this.pointer, _sel_instantiateInitialViewController); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// instantiateInitialViewControllerWithCreator: + UIViewController? instantiateInitialViewControllerWithCreator_( + ObjCBlock_UIViewController_NSCoder? block) { + final _ret = _objc_msgSend_508( + this.pointer, + _sel_instantiateInitialViewControllerWithCreator_, + block?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// instantiateViewControllerWithIdentifier: + UIViewController instantiateViewControllerWithIdentifier_( + objc.NSString identifier) { + final _ret = _objc_msgSend_509(this.pointer, + _sel_instantiateViewControllerWithIdentifier_, identifier.pointer); + return UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// instantiateViewControllerWithIdentifier:creator: + UIViewController instantiateViewControllerWithIdentifier_creator_( + objc.NSString identifier, ObjCBlock_UIViewController_NSCoder? block) { + final _ret = _objc_msgSend_510( + this.pointer, + _sel_instantiateViewControllerWithIdentifier_creator_, + identifier.pointer, + block?.pointer ?? ffi.nullptr); + return UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIStoryboard init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIStoryboard.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIStoryboard new1() { + final _ret = _objc_msgSend_18(_class_UIStoryboard, _sel_new); + return UIStoryboard.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIStoryboard allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIStoryboard, _sel_allocWithZone_, zone); + return UIStoryboard.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIStoryboard alloc() { + final _ret = _objc_msgSend_18(_class_UIStoryboard, _sel_alloc); + return UIStoryboard.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIStoryboard = objc.getClass("UIStoryboard"); +late final _sel_storyboardWithName_bundle_ = + objc.registerName("storyboardWithName:bundle:"); +final _objc_msgSend_385 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// UIViewController +class UIViewController extends UIResponder { + UIViewController._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIViewController] that points to the same underlying object as [other]. + UIViewController.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIViewController] that wraps the given raw object pointer. + UIViewController.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIViewController]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIViewController); + } + + /// initWithNibName:bundle: + UIViewController initWithNibName_bundle_( + objc.NSString? nibNameOrNil, NSBundle? nibBundleOrNil) { + final _ret = _objc_msgSend_386( + this.pointer, + _sel_initWithNibName_bundle_, + nibNameOrNil?.pointer ?? ffi.nullptr, + nibBundleOrNil?.pointer ?? ffi.nullptr); + return UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIViewController? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// view + UIView get view { + final _ret = _objc_msgSend_387(this.pointer, _sel_view); + return UIView.castFromPointer(_ret, retain: true, release: true); + } + + /// setView: + set view(UIView value) { + return _objc_msgSend_388(this.pointer, _sel_setView_, value.pointer); + } + + /// loadView + void loadView() { + _objc_msgSend_4(this.pointer, _sel_loadView); + } + + /// loadViewIfNeeded + void loadViewIfNeeded() { + _objc_msgSend_4(this.pointer, _sel_loadViewIfNeeded); + } + + /// viewIfLoaded + UIView? get viewIfLoaded { + final _ret = _objc_msgSend_123(this.pointer, _sel_viewIfLoaded); + return _ret.address == 0 + ? null + : UIView.castFromPointer(_ret, retain: true, release: true); + } + + /// viewWillUnload + void viewWillUnload() { + _objc_msgSend_4(this.pointer, _sel_viewWillUnload); + } + + /// viewDidUnload + void viewDidUnload() { + _objc_msgSend_4(this.pointer, _sel_viewDidUnload); + } + + /// viewDidLoad + void viewDidLoad() { + _objc_msgSend_4(this.pointer, _sel_viewDidLoad); + } + + /// isViewLoaded + bool get viewLoaded { + return _objc_msgSend_5(this.pointer, _sel_isViewLoaded); + } + + /// nibName + objc.NSString? get nibName { + final _ret = _objc_msgSend_29(this.pointer, _sel_nibName); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// nibBundle + NSBundle? get nibBundle { + final _ret = _objc_msgSend_389(this.pointer, _sel_nibBundle); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// storyboard + UIStoryboard? get storyboard { + final _ret = _objc_msgSend_390(this.pointer, _sel_storyboard); + return _ret.address == 0 + ? null + : UIStoryboard.castFromPointer(_ret, retain: true, release: true); + } + + /// performSegueWithIdentifier:sender: + void performSegueWithIdentifier_sender_( + objc.NSString identifier, objc.ObjCObjectBase? sender) { + _objc_msgSend_391(this.pointer, _sel_performSegueWithIdentifier_sender_, + identifier.pointer, sender?.pointer ?? ffi.nullptr); + } + + /// shouldPerformSegueWithIdentifier:sender: + bool shouldPerformSegueWithIdentifier_sender_( + objc.NSString identifier, objc.ObjCObjectBase? sender) { + return _objc_msgSend_392( + this.pointer, + _sel_shouldPerformSegueWithIdentifier_sender_, + identifier.pointer, + sender?.pointer ?? ffi.nullptr); + } + + /// prepareForSegue:sender: + void prepareForSegue_sender_( + UIStoryboardSegue segue, objc.ObjCObjectBase? sender) { + _objc_msgSend_396(this.pointer, _sel_prepareForSegue_sender_, segue.pointer, + sender?.pointer ?? ffi.nullptr); + } + + /// canPerformUnwindSegueAction:fromViewController:sender: + bool canPerformUnwindSegueAction_fromViewController_sender_( + ffi.Pointer action, + UIViewController fromViewController, + objc.ObjCObjectBase? sender) { + return _objc_msgSend_397( + this.pointer, + _sel_canPerformUnwindSegueAction_fromViewController_sender_, + action, + fromViewController.pointer, + sender?.pointer ?? ffi.nullptr); + } + + /// canPerformUnwindSegueAction:fromViewController:withSender: + bool canPerformUnwindSegueAction_fromViewController_withSender_( + ffi.Pointer action, + UIViewController fromViewController, + objc.ObjCObjectBase sender) { + return _objc_msgSend_398( + this.pointer, + _sel_canPerformUnwindSegueAction_fromViewController_withSender_, + action, + fromViewController.pointer, + sender.pointer); + } + + /// allowedChildViewControllersForUnwindingFromSource: + objc.NSArray allowedChildViewControllersForUnwindingFromSource_( + UIStoryboardUnwindSegueSource source) { + final _ret = _objc_msgSend_399( + this.pointer, + _sel_allowedChildViewControllersForUnwindingFromSource_, + source.pointer); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// childViewControllerContainingSegueSource: + UIViewController? childViewControllerContainingSegueSource_( + UIStoryboardUnwindSegueSource source) { + final _ret = _objc_msgSend_400(this.pointer, + _sel_childViewControllerContainingSegueSource_, source.pointer); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// viewControllerForUnwindSegueAction:fromViewController:withSender: + UIViewController? + viewControllerForUnwindSegueAction_fromViewController_withSender_( + ffi.Pointer action, + UIViewController fromViewController, + objc.ObjCObjectBase? sender) { + final _ret = _objc_msgSend_401( + this.pointer, + _sel_viewControllerForUnwindSegueAction_fromViewController_withSender_, + action, + fromViewController.pointer, + sender?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// unwindForSegue:towardsViewController: + void unwindForSegue_towardsViewController_( + UIStoryboardSegue unwindSegue, UIViewController subsequentVC) { + _objc_msgSend_402(this.pointer, _sel_unwindForSegue_towardsViewController_, + unwindSegue.pointer, subsequentVC.pointer); + } + + /// segueForUnwindingToViewController:fromViewController:identifier: + UIStoryboardSegue? + segueForUnwindingToViewController_fromViewController_identifier_( + UIViewController toViewController, + UIViewController fromViewController, + objc.NSString? identifier) { + final _ret = _objc_msgSend_403( + this.pointer, + _sel_segueForUnwindingToViewController_fromViewController_identifier_, + toViewController.pointer, + fromViewController.pointer, + identifier?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIStoryboardSegue.castFromPointer(_ret, retain: true, release: true); + } + + /// viewWillAppear: + void viewWillAppear_(bool animated) { + _objc_msgSend_372(this.pointer, _sel_viewWillAppear_, animated); + } + + /// viewIsAppearing: + void viewIsAppearing_(bool animated) { + _objc_msgSend_372(this.pointer, _sel_viewIsAppearing_, animated); + } + + /// viewDidAppear: + void viewDidAppear_(bool animated) { + _objc_msgSend_372(this.pointer, _sel_viewDidAppear_, animated); + } + + /// viewWillDisappear: + void viewWillDisappear_(bool animated) { + _objc_msgSend_372(this.pointer, _sel_viewWillDisappear_, animated); + } + + /// viewDidDisappear: + void viewDidDisappear_(bool animated) { + _objc_msgSend_372(this.pointer, _sel_viewDidDisappear_, animated); + } + + /// viewWillLayoutSubviews + void viewWillLayoutSubviews() { + _objc_msgSend_4(this.pointer, _sel_viewWillLayoutSubviews); + } + + /// viewDidLayoutSubviews + void viewDidLayoutSubviews() { + _objc_msgSend_4(this.pointer, _sel_viewDidLayoutSubviews); + } + + /// title + objc.NSString? get title { + final _ret = _objc_msgSend_29(this.pointer, _sel_title); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTitle: + set title(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setTitle_, value?.pointer ?? ffi.nullptr); + } + + /// didReceiveMemoryWarning + void didReceiveMemoryWarning() { + _objc_msgSend_4(this.pointer, _sel_didReceiveMemoryWarning); + } + + /// parentViewController + UIViewController? get parentViewController { + final _ret = _objc_msgSend_404(this.pointer, _sel_parentViewController); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// modalViewController + UIViewController? get modalViewController { + final _ret = _objc_msgSend_404(this.pointer, _sel_modalViewController); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// presentedViewController + UIViewController? get presentedViewController { + final _ret = _objc_msgSend_404(this.pointer, _sel_presentedViewController); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// presentingViewController + UIViewController? get presentingViewController { + final _ret = _objc_msgSend_404(this.pointer, _sel_presentingViewController); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// definesPresentationContext + bool get definesPresentationContext { + return _objc_msgSend_5(this.pointer, _sel_definesPresentationContext); + } + + /// setDefinesPresentationContext: + set definesPresentationContext(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setDefinesPresentationContext_, value); + } + + /// providesPresentationContextTransitionStyle + bool get providesPresentationContextTransitionStyle { + return _objc_msgSend_5( + this.pointer, _sel_providesPresentationContextTransitionStyle); + } + + /// setProvidesPresentationContextTransitionStyle: + set providesPresentationContextTransitionStyle(bool value) { + return _objc_msgSend_6(this.pointer, + _sel_setProvidesPresentationContextTransitionStyle_, value); + } + + /// restoresFocusAfterTransition + bool get restoresFocusAfterTransition { + return _objc_msgSend_5(this.pointer, _sel_restoresFocusAfterTransition); + } + + /// setRestoresFocusAfterTransition: + set restoresFocusAfterTransition(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setRestoresFocusAfterTransition_, value); + } + + /// focusGroupIdentifier + objc.NSString? get focusGroupIdentifier { + final _ret = _objc_msgSend_29(this.pointer, _sel_focusGroupIdentifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setFocusGroupIdentifier: + set focusGroupIdentifier(objc.NSString? value) { + return _objc_msgSend_103(this.pointer, _sel_setFocusGroupIdentifier_, + value?.pointer ?? ffi.nullptr); + } + + /// interactionActivityTrackingBaseName + objc.NSString? get interactionActivityTrackingBaseName { + final _ret = _objc_msgSend_29( + this.pointer, _sel_interactionActivityTrackingBaseName); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setInteractionActivityTrackingBaseName: + set interactionActivityTrackingBaseName(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, + _sel_setInteractionActivityTrackingBaseName_, + value?.pointer ?? ffi.nullptr); + } + + /// isBeingPresented + bool get beingPresented { + return _objc_msgSend_5(this.pointer, _sel_isBeingPresented); + } + + /// isBeingDismissed + bool get beingDismissed { + return _objc_msgSend_5(this.pointer, _sel_isBeingDismissed); + } + + /// isMovingToParentViewController + bool get movingToParentViewController { + return _objc_msgSend_5(this.pointer, _sel_isMovingToParentViewController); + } + + /// isMovingFromParentViewController + bool get movingFromParentViewController { + return _objc_msgSend_5(this.pointer, _sel_isMovingFromParentViewController); + } + + /// presentViewController:animated:completion: + void presentViewController_animated_completion_( + UIViewController viewControllerToPresent, + bool flag, + ObjCBlock_ffiVoid? completion) { + _objc_msgSend_405( + this.pointer, + _sel_presentViewController_animated_completion_, + viewControllerToPresent.pointer, + flag, + completion?.pointer ?? ffi.nullptr); + } + + /// dismissViewControllerAnimated:completion: + void dismissViewControllerAnimated_completion_( + bool flag, ObjCBlock_ffiVoid? completion) { + _objc_msgSend_406( + this.pointer, + _sel_dismissViewControllerAnimated_completion_, + flag, + completion?.pointer ?? ffi.nullptr); + } + + /// presentModalViewController:animated: + void presentModalViewController_animated_( + UIViewController modalViewController, bool animated) { + _objc_msgSend_407(this.pointer, _sel_presentModalViewController_animated_, + modalViewController.pointer, animated); + } + + /// dismissModalViewControllerAnimated: + void dismissModalViewControllerAnimated_(bool animated) { + _objc_msgSend_372( + this.pointer, _sel_dismissModalViewControllerAnimated_, animated); + } + + /// modalTransitionStyle + UIModalTransitionStyle get modalTransitionStyle { + final _ret = _objc_msgSend_408(this.pointer, _sel_modalTransitionStyle); + return UIModalTransitionStyle.fromValue(_ret); + } + + /// setModalTransitionStyle: + set modalTransitionStyle(UIModalTransitionStyle value) { + return _objc_msgSend_409( + this.pointer, _sel_setModalTransitionStyle_, value.value); + } + + /// modalPresentationStyle + UIModalPresentationStyle get modalPresentationStyle { + final _ret = _objc_msgSend_410(this.pointer, _sel_modalPresentationStyle); + return UIModalPresentationStyle.fromValue(_ret); + } + + /// setModalPresentationStyle: + set modalPresentationStyle(UIModalPresentationStyle value) { + return _objc_msgSend_411( + this.pointer, _sel_setModalPresentationStyle_, value.value); + } + + /// modalPresentationCapturesStatusBarAppearance + bool get modalPresentationCapturesStatusBarAppearance { + return _objc_msgSend_5( + this.pointer, _sel_modalPresentationCapturesStatusBarAppearance); + } + + /// setModalPresentationCapturesStatusBarAppearance: + set modalPresentationCapturesStatusBarAppearance(bool value) { + return _objc_msgSend_6(this.pointer, + _sel_setModalPresentationCapturesStatusBarAppearance_, value); + } + + /// disablesAutomaticKeyboardDismissal + bool get disablesAutomaticKeyboardDismissal { + return _objc_msgSend_5( + this.pointer, _sel_disablesAutomaticKeyboardDismissal); + } + + /// wantsFullScreenLayout + bool get wantsFullScreenLayout { + return _objc_msgSend_5(this.pointer, _sel_wantsFullScreenLayout); + } + + /// setWantsFullScreenLayout: + set wantsFullScreenLayout(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setWantsFullScreenLayout_, value); + } + + /// edgesForExtendedLayout + UIRectEdge get edgesForExtendedLayout { + final _ret = _objc_msgSend_412(this.pointer, _sel_edgesForExtendedLayout); + return UIRectEdge.fromValue(_ret); + } + + /// setEdgesForExtendedLayout: + set edgesForExtendedLayout(UIRectEdge value) { + return _objc_msgSend_413( + this.pointer, _sel_setEdgesForExtendedLayout_, value.value); + } + + /// extendedLayoutIncludesOpaqueBars + bool get extendedLayoutIncludesOpaqueBars { + return _objc_msgSend_5(this.pointer, _sel_extendedLayoutIncludesOpaqueBars); + } + + /// setExtendedLayoutIncludesOpaqueBars: + set extendedLayoutIncludesOpaqueBars(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setExtendedLayoutIncludesOpaqueBars_, value); + } + + /// automaticallyAdjustsScrollViewInsets + bool get automaticallyAdjustsScrollViewInsets { + return _objc_msgSend_5( + this.pointer, _sel_automaticallyAdjustsScrollViewInsets); + } + + /// setAutomaticallyAdjustsScrollViewInsets: + set automaticallyAdjustsScrollViewInsets(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setAutomaticallyAdjustsScrollViewInsets_, value); + } + + /// setContentScrollView:forEdge: + void setContentScrollView_forEdge_( + UIScrollView? scrollView, NSDirectionalRectEdge edge) { + _objc_msgSend_501(this.pointer, _sel_setContentScrollView_forEdge_, + scrollView?.pointer ?? ffi.nullptr, edge.value); + } + + /// contentScrollViewForEdge: + UIScrollView? contentScrollViewForEdge_(NSDirectionalRectEdge edge) { + final _ret = _objc_msgSend_502( + this.pointer, _sel_contentScrollViewForEdge_, edge.value); + return _ret.address == 0 + ? null + : UIScrollView.castFromPointer(_ret, retain: true, release: true); + } + + /// preferredContentSize + void getPreferredContentSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_preferredContentSize) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_preferredContentSize); + } + + /// setPreferredContentSize: + set preferredContentSize(CGSize value) { + return _objc_msgSend_92(this.pointer, _sel_setPreferredContentSize_, value); + } + + /// preferredStatusBarStyle + UIStatusBarStyle get preferredStatusBarStyle { + final _ret = _objc_msgSend_503(this.pointer, _sel_preferredStatusBarStyle); + return UIStatusBarStyle.fromValue(_ret); + } + + /// prefersStatusBarHidden + bool get prefersStatusBarHidden { + return _objc_msgSend_5(this.pointer, _sel_prefersStatusBarHidden); + } + + /// preferredStatusBarUpdateAnimation + UIStatusBarAnimation get preferredStatusBarUpdateAnimation { + final _ret = + _objc_msgSend_504(this.pointer, _sel_preferredStatusBarUpdateAnimation); + return UIStatusBarAnimation.fromValue(_ret); + } + + /// setNeedsStatusBarAppearanceUpdate + void setNeedsStatusBarAppearanceUpdate() { + _objc_msgSend_4(this.pointer, _sel_setNeedsStatusBarAppearanceUpdate); + } + + /// targetViewControllerForAction:sender: + UIViewController? targetViewControllerForAction_sender_( + ffi.Pointer action, objc.ObjCObjectBase? sender) { + final _ret = _objc_msgSend_505( + this.pointer, + _sel_targetViewControllerForAction_sender_, + action, + sender?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// showViewController:sender: + void showViewController_sender_( + UIViewController vc, objc.ObjCObjectBase? sender) { + _objc_msgSend_506(this.pointer, _sel_showViewController_sender_, vc.pointer, + sender?.pointer ?? ffi.nullptr); + } + + /// showDetailViewController:sender: + void showDetailViewController_sender_( + UIViewController vc, objc.ObjCObjectBase? sender) { + _objc_msgSend_506(this.pointer, _sel_showDetailViewController_sender_, + vc.pointer, sender?.pointer ?? ffi.nullptr); + } + + /// preferredUserInterfaceStyle + UIUserInterfaceStyle get preferredUserInterfaceStyle { + final _ret = + _objc_msgSend_141(this.pointer, _sel_preferredUserInterfaceStyle); + return UIUserInterfaceStyle.fromValue(_ret); + } + + /// setNeedsUserInterfaceAppearanceUpdate + void setNeedsUserInterfaceAppearanceUpdate() { + _objc_msgSend_4(this.pointer, _sel_setNeedsUserInterfaceAppearanceUpdate); + } + + /// overrideUserInterfaceStyle + UIUserInterfaceStyle get overrideUserInterfaceStyle { + final _ret = + _objc_msgSend_141(this.pointer, _sel_overrideUserInterfaceStyle); + return UIUserInterfaceStyle.fromValue(_ret); + } + + /// setOverrideUserInterfaceStyle: + set overrideUserInterfaceStyle(UIUserInterfaceStyle value) { + return _objc_msgSend_507( + this.pointer, _sel_setOverrideUserInterfaceStyle_, value.value); + } + + /// init + UIViewController init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIViewController new1() { + final _ret = _objc_msgSend_18(_class_UIViewController, _sel_new); + return UIViewController.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIViewController allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIViewController, _sel_allocWithZone_, zone); + return UIViewController.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIViewController alloc() { + final _ret = _objc_msgSend_18(_class_UIViewController, _sel_alloc); + return UIViewController.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIViewController = objc.getClass("UIViewController"); +late final _sel_initWithNibName_bundle_ = + objc.registerName("initWithNibName:bundle:"); +final _objc_msgSend_386 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +final _objc_msgSend_387 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setView_ = objc.registerName("setView:"); +final _objc_msgSend_388 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_loadView = objc.registerName("loadView"); +late final _sel_loadViewIfNeeded = objc.registerName("loadViewIfNeeded"); +late final _sel_viewIfLoaded = objc.registerName("viewIfLoaded"); +late final _sel_viewWillUnload = objc.registerName("viewWillUnload"); +late final _sel_viewDidUnload = objc.registerName("viewDidUnload"); +late final _sel_viewDidLoad = objc.registerName("viewDidLoad"); +late final _sel_isViewLoaded = objc.registerName("isViewLoaded"); +late final _sel_nibName = objc.registerName("nibName"); +late final _sel_nibBundle = objc.registerName("nibBundle"); +final _objc_msgSend_389 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_storyboard = objc.registerName("storyboard"); +final _objc_msgSend_390 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_performSegueWithIdentifier_sender_ = + objc.registerName("performSegueWithIdentifier:sender:"); +final _objc_msgSend_391 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_shouldPerformSegueWithIdentifier_sender_ = + objc.registerName("shouldPerformSegueWithIdentifier:sender:"); +final _objc_msgSend_392 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// UIStoryboardSegue +class UIStoryboardSegue extends objc.NSObject { + UIStoryboardSegue._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIStoryboardSegue] that points to the same underlying object as [other]. + UIStoryboardSegue.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIStoryboardSegue] that wraps the given raw object pointer. + UIStoryboardSegue.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIStoryboardSegue]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIStoryboardSegue); + } + + /// segueWithIdentifier:source:destination:performHandler: + static UIStoryboardSegue + segueWithIdentifier_source_destination_performHandler_( + objc.NSString? identifier, + UIViewController source, + UIViewController destination, + ObjCBlock_ffiVoid performHandler) { + final _ret = _objc_msgSend_393( + _class_UIStoryboardSegue, + _sel_segueWithIdentifier_source_destination_performHandler_, + identifier?.pointer ?? ffi.nullptr, + source.pointer, + destination.pointer, + performHandler.pointer); + return UIStoryboardSegue.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithIdentifier:source:destination: + UIStoryboardSegue initWithIdentifier_source_destination_( + objc.NSString? identifier, + UIViewController source, + UIViewController destination) { + final _ret = _objc_msgSend_394( + this.pointer, + _sel_initWithIdentifier_source_destination_, + identifier?.pointer ?? ffi.nullptr, + source.pointer, + destination.pointer); + return UIStoryboardSegue.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIStoryboardSegue init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIStoryboardSegue.castFromPointer(_ret, retain: true, release: true); + } + + /// identifier + objc.NSString? get identifier { + final _ret = _objc_msgSend_29(this.pointer, _sel_identifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// sourceViewController + UIViewController get sourceViewController { + final _ret = _objc_msgSend_395(this.pointer, _sel_sourceViewController); + return UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// destinationViewController + UIViewController get destinationViewController { + final _ret = + _objc_msgSend_395(this.pointer, _sel_destinationViewController); + return UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// perform + void perform() { + _objc_msgSend_4(this.pointer, _sel_perform); + } + + /// new + static UIStoryboardSegue new1() { + final _ret = _objc_msgSend_18(_class_UIStoryboardSegue, _sel_new); + return UIStoryboardSegue.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIStoryboardSegue allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIStoryboardSegue, _sel_allocWithZone_, zone); + return UIStoryboardSegue.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIStoryboardSegue alloc() { + final _ret = _objc_msgSend_18(_class_UIStoryboardSegue, _sel_alloc); + return UIStoryboardSegue.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIStoryboardSegue = objc.getClass("UIStoryboardSegue"); +void _ObjCBlock_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, +) => + block.ref.target + .cast>() + .asFunction()(); +void _ObjCBlock_ffiVoid_closureTrampoline( + ffi.Pointer block, +) => + (objc.getBlockClosure(block) as void Function())(); + +class ObjCBlock_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_ffiVoid._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid.fromFunctionPointer( + ffi.Pointer> ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer)>( + _ObjCBlock_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid.fromFunction(void Function() fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer)>( + _ObjCBlock_ffiVoid_closureTrampoline) + .cast(), + () => fn())); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid.listener(void Function() fn) + : this._((objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + () => fn()))); + static ffi.NativeCallable)>? + _dartFuncListenerTrampoline; + + void call() => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block)>>() + .asFunction)>()( + pointer, + ); +} + +late final _sel_segueWithIdentifier_source_destination_performHandler_ = + objc.registerName("segueWithIdentifier:source:destination:performHandler:"); +final _objc_msgSend_393 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithIdentifier_source_destination_ = + objc.registerName("initWithIdentifier:source:destination:"); +final _objc_msgSend_394 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_identifier = objc.registerName("identifier"); +late final _sel_sourceViewController = + objc.registerName("sourceViewController"); +final _objc_msgSend_395 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_destinationViewController = + objc.registerName("destinationViewController"); +late final _sel_perform = objc.registerName("perform"); +late final _sel_prepareForSegue_sender_ = + objc.registerName("prepareForSegue:sender:"); +final _objc_msgSend_396 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_canPerformUnwindSegueAction_fromViewController_sender_ = + objc.registerName("canPerformUnwindSegueAction:fromViewController:sender:"); +final _objc_msgSend_397 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_canPerformUnwindSegueAction_fromViewController_withSender_ = + objc.registerName( + "canPerformUnwindSegueAction:fromViewController:withSender:"); +final _objc_msgSend_398 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// UIStoryboardUnwindSegueSource +class UIStoryboardUnwindSegueSource extends objc.NSObject { + UIStoryboardUnwindSegueSource._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIStoryboardUnwindSegueSource] that points to the same underlying object as [other]. + UIStoryboardUnwindSegueSource.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIStoryboardUnwindSegueSource] that wraps the given raw object pointer. + UIStoryboardUnwindSegueSource.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIStoryboardUnwindSegueSource]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIStoryboardUnwindSegueSource); + } + + /// init + UIStoryboardUnwindSegueSource init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIStoryboardUnwindSegueSource.castFromPointer(_ret, + retain: true, release: true); + } + + /// sourceViewController + UIViewController get sourceViewController { + final _ret = _objc_msgSend_395(this.pointer, _sel_sourceViewController); + return UIViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// unwindAction + ffi.Pointer get unwindAction { + return _objc_msgSend_361(this.pointer, _sel_unwindAction); + } + + /// sender + objc.ObjCObjectBase? get sender { + final _ret = _objc_msgSend_2(this.pointer, _sel_sender); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// new + static UIStoryboardUnwindSegueSource new1() { + final _ret = + _objc_msgSend_18(_class_UIStoryboardUnwindSegueSource, _sel_new); + return UIStoryboardUnwindSegueSource.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIStoryboardUnwindSegueSource allocWithZone_( + ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIStoryboardUnwindSegueSource, _sel_allocWithZone_, zone); + return UIStoryboardUnwindSegueSource.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIStoryboardUnwindSegueSource alloc() { + final _ret = + _objc_msgSend_18(_class_UIStoryboardUnwindSegueSource, _sel_alloc); + return UIStoryboardUnwindSegueSource.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIStoryboardUnwindSegueSource = + objc.getClass("UIStoryboardUnwindSegueSource"); +late final _sel_unwindAction = objc.registerName("unwindAction"); +late final _sel_sender = objc.registerName("sender"); +late final _sel_allowedChildViewControllersForUnwindingFromSource_ = + objc.registerName("allowedChildViewControllersForUnwindingFromSource:"); +final _objc_msgSend_399 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_childViewControllerContainingSegueSource_ = + objc.registerName("childViewControllerContainingSegueSource:"); +final _objc_msgSend_400 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_viewControllerForUnwindSegueAction_fromViewController_withSender_ = + objc.registerName( + "viewControllerForUnwindSegueAction:fromViewController:withSender:"); +final _objc_msgSend_401 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_unwindForSegue_towardsViewController_ = + objc.registerName("unwindForSegue:towardsViewController:"); +final _objc_msgSend_402 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_segueForUnwindingToViewController_fromViewController_identifier_ = + objc.registerName( + "segueForUnwindingToViewController:fromViewController:identifier:"); +final _objc_msgSend_403 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_viewWillAppear_ = objc.registerName("viewWillAppear:"); +late final _sel_viewIsAppearing_ = objc.registerName("viewIsAppearing:"); +late final _sel_viewDidAppear_ = objc.registerName("viewDidAppear:"); +late final _sel_viewWillDisappear_ = objc.registerName("viewWillDisappear:"); +late final _sel_viewDidDisappear_ = objc.registerName("viewDidDisappear:"); +late final _sel_viewWillLayoutSubviews = + objc.registerName("viewWillLayoutSubviews"); +late final _sel_viewDidLayoutSubviews = + objc.registerName("viewDidLayoutSubviews"); +late final _sel_didReceiveMemoryWarning = + objc.registerName("didReceiveMemoryWarning"); +late final _sel_parentViewController = + objc.registerName("parentViewController"); +final _objc_msgSend_404 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_modalViewController = objc.registerName("modalViewController"); +late final _sel_presentedViewController = + objc.registerName("presentedViewController"); +late final _sel_presentingViewController = + objc.registerName("presentingViewController"); +late final _sel_definesPresentationContext = + objc.registerName("definesPresentationContext"); +late final _sel_setDefinesPresentationContext_ = + objc.registerName("setDefinesPresentationContext:"); +late final _sel_providesPresentationContextTransitionStyle = + objc.registerName("providesPresentationContextTransitionStyle"); +late final _sel_setProvidesPresentationContextTransitionStyle_ = + objc.registerName("setProvidesPresentationContextTransitionStyle:"); +late final _sel_restoresFocusAfterTransition = + objc.registerName("restoresFocusAfterTransition"); +late final _sel_setRestoresFocusAfterTransition_ = + objc.registerName("setRestoresFocusAfterTransition:"); +late final _sel_interactionActivityTrackingBaseName = + objc.registerName("interactionActivityTrackingBaseName"); +late final _sel_setInteractionActivityTrackingBaseName_ = + objc.registerName("setInteractionActivityTrackingBaseName:"); +late final _sel_isBeingPresented = objc.registerName("isBeingPresented"); +late final _sel_isBeingDismissed = objc.registerName("isBeingDismissed"); +late final _sel_isMovingToParentViewController = + objc.registerName("isMovingToParentViewController"); +late final _sel_isMovingFromParentViewController = + objc.registerName("isMovingFromParentViewController"); +late final _sel_presentViewController_animated_completion_ = + objc.registerName("presentViewController:animated:completion:"); +final _objc_msgSend_405 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool, + ffi.Pointer)>(); +late final _sel_dismissViewControllerAnimated_completion_ = + objc.registerName("dismissViewControllerAnimated:completion:"); +final _objc_msgSend_406 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + bool, + ffi.Pointer)>(); +late final _sel_presentModalViewController_animated_ = + objc.registerName("presentModalViewController:animated:"); +final _objc_msgSend_407 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_dismissModalViewControllerAnimated_ = + objc.registerName("dismissModalViewControllerAnimated:"); + +enum UIModalTransitionStyle { + UIModalTransitionStyleCoverVertical(0), + UIModalTransitionStyleFlipHorizontal(1), + UIModalTransitionStyleCrossDissolve(2), + UIModalTransitionStylePartialCurl(3); + + final int value; + const UIModalTransitionStyle(this.value); + + static UIModalTransitionStyle fromValue(int value) => switch (value) { + 0 => UIModalTransitionStyleCoverVertical, + 1 => UIModalTransitionStyleFlipHorizontal, + 2 => UIModalTransitionStyleCrossDissolve, + 3 => UIModalTransitionStylePartialCurl, + _ => throw ArgumentError( + "Unknown value for UIModalTransitionStyle: $value"), + }; +} + +late final _sel_modalTransitionStyle = + objc.registerName("modalTransitionStyle"); +final _objc_msgSend_408 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setModalTransitionStyle_ = + objc.registerName("setModalTransitionStyle:"); +final _objc_msgSend_409 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +enum UIModalPresentationStyle { + UIModalPresentationFullScreen(0), + UIModalPresentationPageSheet(1), + UIModalPresentationFormSheet(2), + UIModalPresentationCurrentContext(3), + UIModalPresentationCustom(4), + UIModalPresentationOverFullScreen(5), + UIModalPresentationOverCurrentContext(6), + UIModalPresentationPopover(7), + UIModalPresentationBlurOverFullScreen(8), + UIModalPresentationNone(-1), + UIModalPresentationAutomatic(-2); + + final int value; + const UIModalPresentationStyle(this.value); + + static UIModalPresentationStyle fromValue(int value) => switch (value) { + 0 => UIModalPresentationFullScreen, + 1 => UIModalPresentationPageSheet, + 2 => UIModalPresentationFormSheet, + 3 => UIModalPresentationCurrentContext, + 4 => UIModalPresentationCustom, + 5 => UIModalPresentationOverFullScreen, + 6 => UIModalPresentationOverCurrentContext, + 7 => UIModalPresentationPopover, + 8 => UIModalPresentationBlurOverFullScreen, + -1 => UIModalPresentationNone, + -2 => UIModalPresentationAutomatic, + _ => throw ArgumentError( + "Unknown value for UIModalPresentationStyle: $value"), + }; +} + +late final _sel_modalPresentationStyle = + objc.registerName("modalPresentationStyle"); +final _objc_msgSend_410 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setModalPresentationStyle_ = + objc.registerName("setModalPresentationStyle:"); +final _objc_msgSend_411 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_modalPresentationCapturesStatusBarAppearance = + objc.registerName("modalPresentationCapturesStatusBarAppearance"); +late final _sel_setModalPresentationCapturesStatusBarAppearance_ = + objc.registerName("setModalPresentationCapturesStatusBarAppearance:"); +late final _sel_disablesAutomaticKeyboardDismissal = + objc.registerName("disablesAutomaticKeyboardDismissal"); +late final _sel_wantsFullScreenLayout = + objc.registerName("wantsFullScreenLayout"); +late final _sel_setWantsFullScreenLayout_ = + objc.registerName("setWantsFullScreenLayout:"); + +enum UIRectEdge { + UIRectEdgeNone(0), + UIRectEdgeTop(1), + UIRectEdgeLeft(2), + UIRectEdgeBottom(4), + UIRectEdgeRight(8), + UIRectEdgeAll(15); + + final int value; + const UIRectEdge(this.value); + + static UIRectEdge fromValue(int value) => switch (value) { + 0 => UIRectEdgeNone, + 1 => UIRectEdgeTop, + 2 => UIRectEdgeLeft, + 4 => UIRectEdgeBottom, + 8 => UIRectEdgeRight, + 15 => UIRectEdgeAll, + _ => throw ArgumentError("Unknown value for UIRectEdge: $value"), + }; +} + +late final _sel_edgesForExtendedLayout = + objc.registerName("edgesForExtendedLayout"); +final _objc_msgSend_412 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setEdgesForExtendedLayout_ = + objc.registerName("setEdgesForExtendedLayout:"); +final _objc_msgSend_413 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_extendedLayoutIncludesOpaqueBars = + objc.registerName("extendedLayoutIncludesOpaqueBars"); +late final _sel_setExtendedLayoutIncludesOpaqueBars_ = + objc.registerName("setExtendedLayoutIncludesOpaqueBars:"); +late final _sel_automaticallyAdjustsScrollViewInsets = + objc.registerName("automaticallyAdjustsScrollViewInsets"); +late final _sel_setAutomaticallyAdjustsScrollViewInsets_ = + objc.registerName("setAutomaticallyAdjustsScrollViewInsets:"); + +/// UIScrollView +class UIScrollView extends UIView { + UIScrollView._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIScrollView] that points to the same underlying object as [other]. + UIScrollView.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIScrollView] that wraps the given raw object pointer. + UIScrollView.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIScrollView]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIScrollView); + } + + /// contentOffset + void getContentOffset(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_60Stret(stret, this.pointer, _sel_contentOffset) + : stret.ref = _objc_msgSend_60(this.pointer, _sel_contentOffset); + } + + /// setContentOffset: + set contentOffset(CGPoint value) { + return _objc_msgSend_61(this.pointer, _sel_setContentOffset_, value); + } + + /// contentSize + void getContentSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_17Stret(stret, this.pointer, _sel_contentSize) + : stret.ref = _objc_msgSend_17(this.pointer, _sel_contentSize); + } + + /// setContentSize: + set contentSize(CGSize value) { + return _objc_msgSend_92(this.pointer, _sel_setContentSize_, value); + } + + /// contentInset + void getContentInset(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_24Stret(stret, this.pointer, _sel_contentInset) + : stret.ref = _objc_msgSend_24(this.pointer, _sel_contentInset); + } + + /// setContentInset: + set contentInset(UIEdgeInsets value) { + return _objc_msgSend_414(this.pointer, _sel_setContentInset_, value); + } + + /// contentAlignmentPoint + void getContentAlignmentPoint(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_60Stret(stret, this.pointer, _sel_contentAlignmentPoint) + : stret.ref = + _objc_msgSend_60(this.pointer, _sel_contentAlignmentPoint); + } + + /// setContentAlignmentPoint: + set contentAlignmentPoint(CGPoint value) { + return _objc_msgSend_61( + this.pointer, _sel_setContentAlignmentPoint_, value); + } + + /// adjustedContentInset + void getAdjustedContentInset(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_24Stret(stret, this.pointer, _sel_adjustedContentInset) + : stret.ref = _objc_msgSend_24(this.pointer, _sel_adjustedContentInset); + } + + /// adjustedContentInsetDidChange + void adjustedContentInsetDidChange() { + _objc_msgSend_4(this.pointer, _sel_adjustedContentInsetDidChange); + } + + /// contentInsetAdjustmentBehavior + UIScrollViewContentInsetAdjustmentBehavior + get contentInsetAdjustmentBehavior { + final _ret = + _objc_msgSend_415(this.pointer, _sel_contentInsetAdjustmentBehavior); + return UIScrollViewContentInsetAdjustmentBehavior.fromValue(_ret); + } + + /// setContentInsetAdjustmentBehavior: + set contentInsetAdjustmentBehavior( + UIScrollViewContentInsetAdjustmentBehavior value) { + return _objc_msgSend_416( + this.pointer, _sel_setContentInsetAdjustmentBehavior_, value.value); + } + + /// automaticallyAdjustsScrollIndicatorInsets + bool get automaticallyAdjustsScrollIndicatorInsets { + return _objc_msgSend_5( + this.pointer, _sel_automaticallyAdjustsScrollIndicatorInsets); + } + + /// setAutomaticallyAdjustsScrollIndicatorInsets: + set automaticallyAdjustsScrollIndicatorInsets(bool value) { + return _objc_msgSend_6(this.pointer, + _sel_setAutomaticallyAdjustsScrollIndicatorInsets_, value); + } + + /// contentLayoutGuide + UILayoutGuide get contentLayoutGuide { + final _ret = _objc_msgSend_435(this.pointer, _sel_contentLayoutGuide); + return UILayoutGuide.castFromPointer(_ret, retain: true, release: true); + } + + /// frameLayoutGuide + UILayoutGuide get frameLayoutGuide { + final _ret = _objc_msgSend_435(this.pointer, _sel_frameLayoutGuide); + return UILayoutGuide.castFromPointer(_ret, retain: true, release: true); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// isDirectionalLockEnabled + bool get directionalLockEnabled { + return _objc_msgSend_5(this.pointer, _sel_isDirectionalLockEnabled); + } + + /// setDirectionalLockEnabled: + set directionalLockEnabled(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setDirectionalLockEnabled_, value); + } + + /// bounces + bool get bounces { + return _objc_msgSend_5(this.pointer, _sel_bounces); + } + + /// setBounces: + set bounces(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setBounces_, value); + } + + /// bouncesHorizontally + bool get bouncesHorizontally { + return _objc_msgSend_5(this.pointer, _sel_bouncesHorizontally); + } + + /// setBouncesHorizontally: + set bouncesHorizontally(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setBouncesHorizontally_, value); + } + + /// bouncesVertically + bool get bouncesVertically { + return _objc_msgSend_5(this.pointer, _sel_bouncesVertically); + } + + /// setBouncesVertically: + set bouncesVertically(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setBouncesVertically_, value); + } + + /// alwaysBounceVertical + bool get alwaysBounceVertical { + return _objc_msgSend_5(this.pointer, _sel_alwaysBounceVertical); + } + + /// setAlwaysBounceVertical: + set alwaysBounceVertical(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setAlwaysBounceVertical_, value); + } + + /// alwaysBounceHorizontal + bool get alwaysBounceHorizontal { + return _objc_msgSend_5(this.pointer, _sel_alwaysBounceHorizontal); + } + + /// setAlwaysBounceHorizontal: + set alwaysBounceHorizontal(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setAlwaysBounceHorizontal_, value); + } + + /// isPagingEnabled + bool get pagingEnabled { + return _objc_msgSend_5(this.pointer, _sel_isPagingEnabled); + } + + /// setPagingEnabled: + set pagingEnabled(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setPagingEnabled_, value); + } + + /// isScrollEnabled + bool get scrollEnabled { + return _objc_msgSend_5(this.pointer, _sel_isScrollEnabled); + } + + /// setScrollEnabled: + set scrollEnabled(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setScrollEnabled_, value); + } + + /// transfersHorizontalScrollingToParent + bool get transfersHorizontalScrollingToParent { + return _objc_msgSend_5( + this.pointer, _sel_transfersHorizontalScrollingToParent); + } + + /// setTransfersHorizontalScrollingToParent: + set transfersHorizontalScrollingToParent(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setTransfersHorizontalScrollingToParent_, value); + } + + /// transfersVerticalScrollingToParent + bool get transfersVerticalScrollingToParent { + return _objc_msgSend_5( + this.pointer, _sel_transfersVerticalScrollingToParent); + } + + /// setTransfersVerticalScrollingToParent: + set transfersVerticalScrollingToParent(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setTransfersVerticalScrollingToParent_, value); + } + + /// showsVerticalScrollIndicator + bool get showsVerticalScrollIndicator { + return _objc_msgSend_5(this.pointer, _sel_showsVerticalScrollIndicator); + } + + /// setShowsVerticalScrollIndicator: + set showsVerticalScrollIndicator(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setShowsVerticalScrollIndicator_, value); + } + + /// showsHorizontalScrollIndicator + bool get showsHorizontalScrollIndicator { + return _objc_msgSend_5(this.pointer, _sel_showsHorizontalScrollIndicator); + } + + /// setShowsHorizontalScrollIndicator: + set showsHorizontalScrollIndicator(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setShowsHorizontalScrollIndicator_, value); + } + + /// indicatorStyle + UIScrollViewIndicatorStyle get indicatorStyle { + final _ret = _objc_msgSend_436(this.pointer, _sel_indicatorStyle); + return UIScrollViewIndicatorStyle.fromValue(_ret); + } + + /// setIndicatorStyle: + set indicatorStyle(UIScrollViewIndicatorStyle value) { + return _objc_msgSend_437( + this.pointer, _sel_setIndicatorStyle_, value.value); + } + + /// verticalScrollIndicatorInsets + void getVerticalScrollIndicatorInsets(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_24Stret( + stret, this.pointer, _sel_verticalScrollIndicatorInsets) + : stret.ref = + _objc_msgSend_24(this.pointer, _sel_verticalScrollIndicatorInsets); + } + + /// setVerticalScrollIndicatorInsets: + set verticalScrollIndicatorInsets(UIEdgeInsets value) { + return _objc_msgSend_414( + this.pointer, _sel_setVerticalScrollIndicatorInsets_, value); + } + + /// horizontalScrollIndicatorInsets + void getHorizontalScrollIndicatorInsets(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_24Stret( + stret, this.pointer, _sel_horizontalScrollIndicatorInsets) + : stret.ref = _objc_msgSend_24( + this.pointer, _sel_horizontalScrollIndicatorInsets); + } + + /// setHorizontalScrollIndicatorInsets: + set horizontalScrollIndicatorInsets(UIEdgeInsets value) { + return _objc_msgSend_414( + this.pointer, _sel_setHorizontalScrollIndicatorInsets_, value); + } + + /// scrollIndicatorInsets + void getScrollIndicatorInsets(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_24Stret(stret, this.pointer, _sel_scrollIndicatorInsets) + : stret.ref = + _objc_msgSend_24(this.pointer, _sel_scrollIndicatorInsets); + } + + /// setScrollIndicatorInsets: + set scrollIndicatorInsets(UIEdgeInsets value) { + return _objc_msgSend_414( + this.pointer, _sel_setScrollIndicatorInsets_, value); + } + + /// decelerationRate + double get decelerationRate { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_decelerationRate) + : _objc_msgSend_11(this.pointer, _sel_decelerationRate); + } + + /// setDecelerationRate: + set decelerationRate(double value) { + return _objc_msgSend_26(this.pointer, _sel_setDecelerationRate_, value); + } + + /// indexDisplayMode + UIScrollViewIndexDisplayMode get indexDisplayMode { + final _ret = _objc_msgSend_438(this.pointer, _sel_indexDisplayMode); + return UIScrollViewIndexDisplayMode.fromValue(_ret); + } + + /// setIndexDisplayMode: + set indexDisplayMode(UIScrollViewIndexDisplayMode value) { + return _objc_msgSend_439( + this.pointer, _sel_setIndexDisplayMode_, value.value); + } + + /// setContentOffset:animated: + void setContentOffset_animated_(CGPoint contentOffset, bool animated) { + _objc_msgSend_440( + this.pointer, _sel_setContentOffset_animated_, contentOffset, animated); + } + + /// scrollRectToVisible:animated: + void scrollRectToVisible_animated_(CGRect rect, bool animated) { + _objc_msgSend_441( + this.pointer, _sel_scrollRectToVisible_animated_, rect, animated); + } + + /// flashScrollIndicators + void flashScrollIndicators() { + _objc_msgSend_4(this.pointer, _sel_flashScrollIndicators); + } + + /// withScrollIndicatorsShownForContentOffsetChanges: + void withScrollIndicatorsShownForContentOffsetChanges_( + ObjCBlock_ffiVoid changes) { + _objc_msgSend_442( + this.pointer, + _sel_withScrollIndicatorsShownForContentOffsetChanges_, + changes.pointer); + } + + /// isTracking + bool get tracking { + return _objc_msgSend_5(this.pointer, _sel_isTracking); + } + + /// isDragging + bool get dragging { + return _objc_msgSend_5(this.pointer, _sel_isDragging); + } + + /// isDecelerating + bool get decelerating { + return _objc_msgSend_5(this.pointer, _sel_isDecelerating); + } + + /// isScrollAnimating + bool get scrollAnimating { + return _objc_msgSend_5(this.pointer, _sel_isScrollAnimating); + } + + /// delaysContentTouches + bool get delaysContentTouches { + return _objc_msgSend_5(this.pointer, _sel_delaysContentTouches); + } + + /// setDelaysContentTouches: + set delaysContentTouches(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setDelaysContentTouches_, value); + } + + /// canCancelContentTouches + bool get canCancelContentTouches { + return _objc_msgSend_5(this.pointer, _sel_canCancelContentTouches); + } + + /// setCanCancelContentTouches: + set canCancelContentTouches(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setCanCancelContentTouches_, value); + } + + /// touchesShouldBegin:withEvent:inContentView: + bool touchesShouldBegin_withEvent_inContentView_( + objc.ObjCObjectBase touches, UIEvent? event, UIView view) { + return _objc_msgSend_443( + this.pointer, + _sel_touchesShouldBegin_withEvent_inContentView_, + touches.pointer, + event?.pointer ?? ffi.nullptr, + view.pointer); + } + + /// touchesShouldCancelInContentView: + bool touchesShouldCancelInContentView_(UIView view) { + return _objc_msgSend_444( + this.pointer, _sel_touchesShouldCancelInContentView_, view.pointer); + } + + /// minimumZoomScale + double get minimumZoomScale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_minimumZoomScale) + : _objc_msgSend_11(this.pointer, _sel_minimumZoomScale); + } + + /// setMinimumZoomScale: + set minimumZoomScale(double value) { + return _objc_msgSend_26(this.pointer, _sel_setMinimumZoomScale_, value); + } + + /// maximumZoomScale + double get maximumZoomScale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_maximumZoomScale) + : _objc_msgSend_11(this.pointer, _sel_maximumZoomScale); + } + + /// setMaximumZoomScale: + set maximumZoomScale(double value) { + return _objc_msgSend_26(this.pointer, _sel_setMaximumZoomScale_, value); + } + + /// zoomScale + double get zoomScale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_zoomScale) + : _objc_msgSend_11(this.pointer, _sel_zoomScale); + } + + /// setZoomScale: + set zoomScale(double value) { + return _objc_msgSend_26(this.pointer, _sel_setZoomScale_, value); + } + + /// setZoomScale:animated: + void setZoomScale_animated_(double scale, bool animated) { + _objc_msgSend_445( + this.pointer, _sel_setZoomScale_animated_, scale, animated); + } + + /// zoomToRect:animated: + void zoomToRect_animated_(CGRect rect, bool animated) { + _objc_msgSend_441(this.pointer, _sel_zoomToRect_animated_, rect, animated); + } + + /// bouncesZoom + bool get bouncesZoom { + return _objc_msgSend_5(this.pointer, _sel_bouncesZoom); + } + + /// setBouncesZoom: + set bouncesZoom(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setBouncesZoom_, value); + } + + /// isZooming + bool get zooming { + return _objc_msgSend_5(this.pointer, _sel_isZooming); + } + + /// isZoomBouncing + bool get zoomBouncing { + return _objc_msgSend_5(this.pointer, _sel_isZoomBouncing); + } + + /// isZoomAnimating + bool get zoomAnimating { + return _objc_msgSend_5(this.pointer, _sel_isZoomAnimating); + } + + /// scrollsToTop + bool get scrollsToTop { + return _objc_msgSend_5(this.pointer, _sel_scrollsToTop); + } + + /// setScrollsToTop: + set scrollsToTop(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setScrollsToTop_, value); + } + + /// stopScrollingAndZooming + void stopScrollingAndZooming() { + _objc_msgSend_4(this.pointer, _sel_stopScrollingAndZooming); + } + + /// panGestureRecognizer + UIPanGestureRecognizer get panGestureRecognizer { + final _ret = _objc_msgSend_449(this.pointer, _sel_panGestureRecognizer); + return UIPanGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// pinchGestureRecognizer + UIPinchGestureRecognizer? get pinchGestureRecognizer { + final _ret = _objc_msgSend_450(this.pointer, _sel_pinchGestureRecognizer); + return _ret.address == 0 + ? null + : UIPinchGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// directionalPressGestureRecognizer + UIGestureRecognizer get directionalPressGestureRecognizer { + final _ret = + _objc_msgSend_451(this.pointer, _sel_directionalPressGestureRecognizer); + return UIGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// keyboardDismissMode + UIScrollViewKeyboardDismissMode get keyboardDismissMode { + final _ret = _objc_msgSend_452(this.pointer, _sel_keyboardDismissMode); + return UIScrollViewKeyboardDismissMode.fromValue(_ret); + } + + /// setKeyboardDismissMode: + set keyboardDismissMode(UIScrollViewKeyboardDismissMode value) { + return _objc_msgSend_453( + this.pointer, _sel_setKeyboardDismissMode_, value.value); + } + + /// refreshControl + UIRefreshControl? get refreshControl { + final _ret = _objc_msgSend_499(this.pointer, _sel_refreshControl); + return _ret.address == 0 + ? null + : UIRefreshControl.castFromPointer(_ret, retain: true, release: true); + } + + /// setRefreshControl: + set refreshControl(UIRefreshControl? value) { + return _objc_msgSend_500( + this.pointer, _sel_setRefreshControl_, value?.pointer ?? ffi.nullptr); + } + + /// allowsKeyboardScrolling + bool get allowsKeyboardScrolling { + return _objc_msgSend_5(this.pointer, _sel_allowsKeyboardScrolling); + } + + /// setAllowsKeyboardScrolling: + set allowsKeyboardScrolling(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setAllowsKeyboardScrolling_, value); + } + + /// layerClass + static objc.ObjCObjectBase getLayerClass() { + final _ret = _objc_msgSend_18(_class_UIScrollView, _sel_layerClass); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// initWithFrame: + UIScrollView initWithFrame_(CGRect frame) { + final _ret = _objc_msgSend_54(this.pointer, _sel_initWithFrame_, frame); + return UIScrollView.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIScrollView? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIScrollView.castFromPointer(_ret, retain: true, release: true); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_( + UISemanticContentAttribute attribute) { + final _ret = _objc_msgSend_111( + _class_UIScrollView, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_, + attribute.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute:relativeToLayoutDirection: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_( + UISemanticContentAttribute semanticContentAttribute, + UIUserInterfaceLayoutDirection layoutDirection) { + final _ret = _objc_msgSend_112( + _class_UIScrollView, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_, + semanticContentAttribute.value, + layoutDirection.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// init + UIScrollView init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIScrollView.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIScrollView new1() { + final _ret = _objc_msgSend_18(_class_UIScrollView, _sel_new); + return UIScrollView.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIScrollView allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIScrollView, _sel_allocWithZone_, zone); + return UIScrollView.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIScrollView alloc() { + final _ret = _objc_msgSend_18(_class_UIScrollView, _sel_alloc); + return UIScrollView.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIScrollView = objc.getClass("UIScrollView"); +late final _sel_contentOffset = objc.registerName("contentOffset"); +late final _sel_setContentOffset_ = objc.registerName("setContentOffset:"); +late final _sel_contentSize = objc.registerName("contentSize"); +late final _sel_setContentSize_ = objc.registerName("setContentSize:"); +late final _sel_contentInset = objc.registerName("contentInset"); +late final _sel_setContentInset_ = objc.registerName("setContentInset:"); +final _objc_msgSend_414 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, UIEdgeInsets)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, UIEdgeInsets)>(); +late final _sel_contentAlignmentPoint = + objc.registerName("contentAlignmentPoint"); +late final _sel_setContentAlignmentPoint_ = + objc.registerName("setContentAlignmentPoint:"); +late final _sel_adjustedContentInset = + objc.registerName("adjustedContentInset"); +late final _sel_adjustedContentInsetDidChange = + objc.registerName("adjustedContentInsetDidChange"); + +enum UIScrollViewContentInsetAdjustmentBehavior { + UIScrollViewContentInsetAdjustmentAutomatic(0), + UIScrollViewContentInsetAdjustmentScrollableAxes(1), + UIScrollViewContentInsetAdjustmentNever(2), + UIScrollViewContentInsetAdjustmentAlways(3); + + final int value; + const UIScrollViewContentInsetAdjustmentBehavior(this.value); + + static UIScrollViewContentInsetAdjustmentBehavior fromValue(int value) => + switch (value) { + 0 => UIScrollViewContentInsetAdjustmentAutomatic, + 1 => UIScrollViewContentInsetAdjustmentScrollableAxes, + 2 => UIScrollViewContentInsetAdjustmentNever, + 3 => UIScrollViewContentInsetAdjustmentAlways, + _ => throw ArgumentError( + "Unknown value for UIScrollViewContentInsetAdjustmentBehavior: $value"), + }; +} + +late final _sel_contentInsetAdjustmentBehavior = + objc.registerName("contentInsetAdjustmentBehavior"); +final _objc_msgSend_415 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setContentInsetAdjustmentBehavior_ = + objc.registerName("setContentInsetAdjustmentBehavior:"); +final _objc_msgSend_416 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_automaticallyAdjustsScrollIndicatorInsets = + objc.registerName("automaticallyAdjustsScrollIndicatorInsets"); +late final _sel_setAutomaticallyAdjustsScrollIndicatorInsets_ = + objc.registerName("setAutomaticallyAdjustsScrollIndicatorInsets:"); + +/// UILayoutGuide +class UILayoutGuide extends objc.NSObject { + UILayoutGuide._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UILayoutGuide] that points to the same underlying object as [other]. + UILayoutGuide.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UILayoutGuide] that wraps the given raw object pointer. + UILayoutGuide.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UILayoutGuide]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UILayoutGuide); + } + + /// layoutFrame + void getLayoutFrame(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_16Stret(stret, this.pointer, _sel_layoutFrame) + : stret.ref = _objc_msgSend_16(this.pointer, _sel_layoutFrame); + } + + /// owningView + UIView? get owningView { + final _ret = _objc_msgSend_123(this.pointer, _sel_owningView); + return _ret.address == 0 + ? null + : UIView.castFromPointer(_ret, retain: true, release: true); + } + + /// setOwningView: + set owningView(UIView? value) { + return _objc_msgSend_417( + this.pointer, _sel_setOwningView_, value?.pointer ?? ffi.nullptr); + } + + /// identifier + objc.NSString get identifier { + final _ret = _objc_msgSend_77(this.pointer, _sel_identifier); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setIdentifier: + set identifier(objc.NSString value) { + return _objc_msgSend_78(this.pointer, _sel_setIdentifier_, value.pointer); + } + + /// leadingAnchor + NSLayoutXAxisAnchor get leadingAnchor { + final _ret = _objc_msgSend_431(this.pointer, _sel_leadingAnchor); + return NSLayoutXAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// trailingAnchor + NSLayoutXAxisAnchor get trailingAnchor { + final _ret = _objc_msgSend_431(this.pointer, _sel_trailingAnchor); + return NSLayoutXAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// leftAnchor + NSLayoutXAxisAnchor get leftAnchor { + final _ret = _objc_msgSend_431(this.pointer, _sel_leftAnchor); + return NSLayoutXAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// rightAnchor + NSLayoutXAxisAnchor get rightAnchor { + final _ret = _objc_msgSend_431(this.pointer, _sel_rightAnchor); + return NSLayoutXAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// topAnchor + NSLayoutYAxisAnchor get topAnchor { + final _ret = _objc_msgSend_433(this.pointer, _sel_topAnchor); + return NSLayoutYAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// bottomAnchor + NSLayoutYAxisAnchor get bottomAnchor { + final _ret = _objc_msgSend_433(this.pointer, _sel_bottomAnchor); + return NSLayoutYAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// widthAnchor + NSLayoutDimension get widthAnchor { + final _ret = _objc_msgSend_434(this.pointer, _sel_widthAnchor); + return NSLayoutDimension.castFromPointer(_ret, retain: true, release: true); + } + + /// heightAnchor + NSLayoutDimension get heightAnchor { + final _ret = _objc_msgSend_434(this.pointer, _sel_heightAnchor); + return NSLayoutDimension.castFromPointer(_ret, retain: true, release: true); + } + + /// centerXAnchor + NSLayoutXAxisAnchor get centerXAnchor { + final _ret = _objc_msgSend_431(this.pointer, _sel_centerXAnchor); + return NSLayoutXAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// centerYAnchor + NSLayoutYAxisAnchor get centerYAnchor { + final _ret = _objc_msgSend_433(this.pointer, _sel_centerYAnchor); + return NSLayoutYAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UILayoutGuide init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UILayoutGuide.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UILayoutGuide new1() { + final _ret = _objc_msgSend_18(_class_UILayoutGuide, _sel_new); + return UILayoutGuide.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UILayoutGuide allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UILayoutGuide, _sel_allocWithZone_, zone); + return UILayoutGuide.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UILayoutGuide alloc() { + final _ret = _objc_msgSend_18(_class_UILayoutGuide, _sel_alloc); + return UILayoutGuide.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UILayoutGuide = objc.getClass("UILayoutGuide"); +late final _sel_layoutFrame = objc.registerName("layoutFrame"); +late final _sel_owningView = objc.registerName("owningView"); +late final _sel_setOwningView_ = objc.registerName("setOwningView:"); +final _objc_msgSend_417 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setIdentifier_ = objc.registerName("setIdentifier:"); + +/// NSLayoutXAxisAnchor +class NSLayoutXAxisAnchor extends NSLayoutAnchor { + NSLayoutXAxisAnchor._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSLayoutXAxisAnchor] that points to the same underlying object as [other]. + NSLayoutXAxisAnchor.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSLayoutXAxisAnchor] that wraps the given raw object pointer. + NSLayoutXAxisAnchor.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSLayoutXAxisAnchor]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSLayoutXAxisAnchor); + } + + /// anchorWithOffsetToAnchor: + NSLayoutDimension anchorWithOffsetToAnchor_(NSLayoutXAxisAnchor otherAnchor) { + final _ret = _objc_msgSend_430( + this.pointer, _sel_anchorWithOffsetToAnchor_, otherAnchor.pointer); + return NSLayoutDimension.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSLayoutXAxisAnchor init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSLayoutXAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static NSLayoutXAxisAnchor new1() { + final _ret = _objc_msgSend_18(_class_NSLayoutXAxisAnchor, _sel_new); + return NSLayoutXAxisAnchor.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static NSLayoutXAxisAnchor allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSLayoutXAxisAnchor, _sel_allocWithZone_, zone); + return NSLayoutXAxisAnchor.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static NSLayoutXAxisAnchor alloc() { + final _ret = _objc_msgSend_18(_class_NSLayoutXAxisAnchor, _sel_alloc); + return NSLayoutXAxisAnchor.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_NSLayoutXAxisAnchor = objc.getClass("NSLayoutXAxisAnchor"); + +/// NSLayoutDimension +class NSLayoutDimension extends NSLayoutAnchor { + NSLayoutDimension._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSLayoutDimension] that points to the same underlying object as [other]. + NSLayoutDimension.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSLayoutDimension] that wraps the given raw object pointer. + NSLayoutDimension.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSLayoutDimension]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSLayoutDimension); + } + + /// constraintEqualToConstant: + NSLayoutConstraint constraintEqualToConstant_(double c) { + final _ret = + _objc_msgSend_427(this.pointer, _sel_constraintEqualToConstant_, c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintGreaterThanOrEqualToConstant: + NSLayoutConstraint constraintGreaterThanOrEqualToConstant_(double c) { + final _ret = _objc_msgSend_427( + this.pointer, _sel_constraintGreaterThanOrEqualToConstant_, c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintLessThanOrEqualToConstant: + NSLayoutConstraint constraintLessThanOrEqualToConstant_(double c) { + final _ret = _objc_msgSend_427( + this.pointer, _sel_constraintLessThanOrEqualToConstant_, c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintEqualToAnchor:multiplier: + NSLayoutConstraint constraintEqualToAnchor_multiplier_( + NSLayoutDimension anchor, double m) { + final _ret = _objc_msgSend_428(this.pointer, + _sel_constraintEqualToAnchor_multiplier_, anchor.pointer, m); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintGreaterThanOrEqualToAnchor:multiplier: + NSLayoutConstraint constraintGreaterThanOrEqualToAnchor_multiplier_( + NSLayoutDimension anchor, double m) { + final _ret = _objc_msgSend_428( + this.pointer, + _sel_constraintGreaterThanOrEqualToAnchor_multiplier_, + anchor.pointer, + m); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintLessThanOrEqualToAnchor:multiplier: + NSLayoutConstraint constraintLessThanOrEqualToAnchor_multiplier_( + NSLayoutDimension anchor, double m) { + final _ret = _objc_msgSend_428(this.pointer, + _sel_constraintLessThanOrEqualToAnchor_multiplier_, anchor.pointer, m); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintEqualToAnchor:multiplier:constant: + NSLayoutConstraint constraintEqualToAnchor_multiplier_constant_( + NSLayoutDimension anchor, double m, double c) { + final _ret = _objc_msgSend_429( + this.pointer, + _sel_constraintEqualToAnchor_multiplier_constant_, + anchor.pointer, + m, + c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintGreaterThanOrEqualToAnchor:multiplier:constant: + NSLayoutConstraint constraintGreaterThanOrEqualToAnchor_multiplier_constant_( + NSLayoutDimension anchor, double m, double c) { + final _ret = _objc_msgSend_429( + this.pointer, + _sel_constraintGreaterThanOrEqualToAnchor_multiplier_constant_, + anchor.pointer, + m, + c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintLessThanOrEqualToAnchor:multiplier:constant: + NSLayoutConstraint constraintLessThanOrEqualToAnchor_multiplier_constant_( + NSLayoutDimension anchor, double m, double c) { + final _ret = _objc_msgSend_429( + this.pointer, + _sel_constraintLessThanOrEqualToAnchor_multiplier_constant_, + anchor.pointer, + m, + c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + NSLayoutDimension init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSLayoutDimension.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSLayoutDimension new1() { + final _ret = _objc_msgSend_18(_class_NSLayoutDimension, _sel_new); + return NSLayoutDimension.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static NSLayoutDimension allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSLayoutDimension, _sel_allocWithZone_, zone); + return NSLayoutDimension.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static NSLayoutDimension alloc() { + final _ret = _objc_msgSend_18(_class_NSLayoutDimension, _sel_alloc); + return NSLayoutDimension.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_NSLayoutDimension = objc.getClass("NSLayoutDimension"); + +/// NSLayoutConstraint +class NSLayoutConstraint extends objc.NSObject { + NSLayoutConstraint._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSLayoutConstraint] that points to the same underlying object as [other]. + NSLayoutConstraint.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSLayoutConstraint] that wraps the given raw object pointer. + NSLayoutConstraint.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSLayoutConstraint]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSLayoutConstraint); + } + + /// constraintsWithVisualFormat:options:metrics:views: + static objc.NSArray constraintsWithVisualFormat_options_metrics_views_( + objc.NSString format, + NSLayoutFormatOptions opts, + objc.NSDictionary? metrics, + objc.NSDictionary views) { + final _ret = _objc_msgSend_418( + _class_NSLayoutConstraint, + _sel_constraintsWithVisualFormat_options_metrics_views_, + format.pointer, + opts.value, + metrics?.pointer ?? ffi.nullptr, + views.pointer); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// constraintWithItem:attribute:relatedBy:toItem:attribute:multiplier:constant: + static NSLayoutConstraint + constraintWithItem_attribute_relatedBy_toItem_attribute_multiplier_constant_( + objc.ObjCObjectBase view1, + NSLayoutAttribute attr1, + NSLayoutRelation relation, + objc.ObjCObjectBase? view2, + NSLayoutAttribute attr2, + double multiplier, + double c) { + final _ret = _objc_msgSend_419( + _class_NSLayoutConstraint, + _sel_constraintWithItem_attribute_relatedBy_toItem_attribute_multiplier_constant_, + view1.pointer, + attr1.value, + relation.value, + view2?.pointer ?? ffi.nullptr, + attr2.value, + multiplier, + c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// priority + double get priority { + return objc.useMsgSendVariants + ? _objc_msgSend_79Fpret(this.pointer, _sel_priority) + : _objc_msgSend_79(this.pointer, _sel_priority); + } + + /// setPriority: + set priority(double value) { + return _objc_msgSend_80(this.pointer, _sel_setPriority_, value); + } + + /// shouldBeArchived + bool get shouldBeArchived { + return _objc_msgSend_5(this.pointer, _sel_shouldBeArchived); + } + + /// setShouldBeArchived: + set shouldBeArchived(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setShouldBeArchived_, value); + } + + /// firstItem + objc.ObjCObjectBase? get firstItem { + final _ret = _objc_msgSend_2(this.pointer, _sel_firstItem); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// secondItem + objc.ObjCObjectBase? get secondItem { + final _ret = _objc_msgSend_2(this.pointer, _sel_secondItem); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// firstAttribute + NSLayoutAttribute get firstAttribute { + final _ret = _objc_msgSend_420(this.pointer, _sel_firstAttribute); + return NSLayoutAttribute.fromValue(_ret); + } + + /// secondAttribute + NSLayoutAttribute get secondAttribute { + final _ret = _objc_msgSend_420(this.pointer, _sel_secondAttribute); + return NSLayoutAttribute.fromValue(_ret); + } + + /// firstAnchor + NSLayoutAnchor get firstAnchor { + final _ret = _objc_msgSend_423(this.pointer, _sel_firstAnchor); + return NSLayoutAnchor.castFromPointer(_ret, retain: true, release: true); + } + + /// secondAnchor + NSLayoutAnchor? get secondAnchor { + final _ret = _objc_msgSend_424(this.pointer, _sel_secondAnchor); + return _ret.address == 0 + ? null + : NSLayoutAnchor.castFromPointer(_ret, retain: true, release: true); + } + + /// relation + NSLayoutRelation get relation { + final _ret = _objc_msgSend_425(this.pointer, _sel_relation); + return NSLayoutRelation.fromValue(_ret); + } + + /// multiplier + double get multiplier { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_multiplier) + : _objc_msgSend_11(this.pointer, _sel_multiplier); + } + + /// constant + double get constant { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_constant) + : _objc_msgSend_11(this.pointer, _sel_constant); + } + + /// setConstant: + set constant(double value) { + return _objc_msgSend_26(this.pointer, _sel_setConstant_, value); + } + + /// isActive + bool get active { + return _objc_msgSend_5(this.pointer, _sel_isActive); + } + + /// setActive: + set active(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setActive_, value); + } + + /// activateConstraints: + static void activateConstraints_(objc.NSArray constraints) { + _objc_msgSend_426(_class_NSLayoutConstraint, _sel_activateConstraints_, + constraints.pointer); + } + + /// deactivateConstraints: + static void deactivateConstraints_(objc.NSArray constraints) { + _objc_msgSend_426(_class_NSLayoutConstraint, _sel_deactivateConstraints_, + constraints.pointer); + } + + /// init + NSLayoutConstraint init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static NSLayoutConstraint new1() { + final _ret = _objc_msgSend_18(_class_NSLayoutConstraint, _sel_new); + return NSLayoutConstraint.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static NSLayoutConstraint allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSLayoutConstraint, _sel_allocWithZone_, zone); + return NSLayoutConstraint.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static NSLayoutConstraint alloc() { + final _ret = _objc_msgSend_18(_class_NSLayoutConstraint, _sel_alloc); + return NSLayoutConstraint.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_NSLayoutConstraint = objc.getClass("NSLayoutConstraint"); + +enum NSLayoutFormatOptions { + NSLayoutFormatAlignAllLeft(2), + NSLayoutFormatAlignAllRight(4), + NSLayoutFormatAlignAllTop(8), + NSLayoutFormatAlignAllBottom(16), + NSLayoutFormatAlignAllLeading(32), + NSLayoutFormatAlignAllTrailing(64), + NSLayoutFormatAlignAllCenterX(512), + NSLayoutFormatAlignAllCenterY(1024), + NSLayoutFormatAlignAllLastBaseline(2048), + NSLayoutFormatAlignAllFirstBaseline(4096), + NSLayoutFormatAlignmentMask(65535), + NSLayoutFormatDirectionLeadingToTrailing(0), + NSLayoutFormatDirectionLeftToRight(65536), + NSLayoutFormatDirectionRightToLeft(131072), + NSLayoutFormatDirectionMask(196608), + NSLayoutFormatSpacingBaselineToBaseline(524288); + + static const NSLayoutFormatAlignAllBaseline = + NSLayoutFormatAlignAllLastBaseline; + static const NSLayoutFormatSpacingEdgeToEdge = + NSLayoutFormatDirectionLeadingToTrailing; + static const NSLayoutFormatSpacingMask = + NSLayoutFormatSpacingBaselineToBaseline; + + final int value; + const NSLayoutFormatOptions(this.value); + + static NSLayoutFormatOptions fromValue(int value) => switch (value) { + 2 => NSLayoutFormatAlignAllLeft, + 4 => NSLayoutFormatAlignAllRight, + 8 => NSLayoutFormatAlignAllTop, + 16 => NSLayoutFormatAlignAllBottom, + 32 => NSLayoutFormatAlignAllLeading, + 64 => NSLayoutFormatAlignAllTrailing, + 512 => NSLayoutFormatAlignAllCenterX, + 1024 => NSLayoutFormatAlignAllCenterY, + 2048 => NSLayoutFormatAlignAllLastBaseline, + 4096 => NSLayoutFormatAlignAllFirstBaseline, + 65535 => NSLayoutFormatAlignmentMask, + 0 => NSLayoutFormatDirectionLeadingToTrailing, + 65536 => NSLayoutFormatDirectionLeftToRight, + 131072 => NSLayoutFormatDirectionRightToLeft, + 196608 => NSLayoutFormatDirectionMask, + 524288 => NSLayoutFormatSpacingBaselineToBaseline, + _ => throw ArgumentError( + "Unknown value for NSLayoutFormatOptions: $value"), + }; + + @override + String toString() { + if (this == NSLayoutFormatAlignAllLastBaseline) + return "NSLayoutFormatOptions.NSLayoutFormatAlignAllLastBaseline, NSLayoutFormatOptions.NSLayoutFormatAlignAllBaseline"; + if (this == NSLayoutFormatDirectionLeadingToTrailing) + return "NSLayoutFormatOptions.NSLayoutFormatDirectionLeadingToTrailing, NSLayoutFormatOptions.NSLayoutFormatSpacingEdgeToEdge"; + if (this == NSLayoutFormatSpacingBaselineToBaseline) + return "NSLayoutFormatOptions.NSLayoutFormatSpacingBaselineToBaseline, NSLayoutFormatOptions.NSLayoutFormatSpacingMask"; + return super.toString(); + } +} + +late final _sel_constraintsWithVisualFormat_options_metrics_views_ = + objc.registerName("constraintsWithVisualFormat:options:metrics:views:"); +final _objc_msgSend_418 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer)>(); + +enum NSLayoutAttribute { + NSLayoutAttributeLeft(1), + NSLayoutAttributeRight(2), + NSLayoutAttributeTop(3), + NSLayoutAttributeBottom(4), + NSLayoutAttributeLeading(5), + NSLayoutAttributeTrailing(6), + NSLayoutAttributeWidth(7), + NSLayoutAttributeHeight(8), + NSLayoutAttributeCenterX(9), + NSLayoutAttributeCenterY(10), + NSLayoutAttributeLastBaseline(11), + NSLayoutAttributeFirstBaseline(12), + NSLayoutAttributeLeftMargin(13), + NSLayoutAttributeRightMargin(14), + NSLayoutAttributeTopMargin(15), + NSLayoutAttributeBottomMargin(16), + NSLayoutAttributeLeadingMargin(17), + NSLayoutAttributeTrailingMargin(18), + NSLayoutAttributeCenterXWithinMargins(19), + NSLayoutAttributeCenterYWithinMargins(20), + NSLayoutAttributeNotAnAttribute(0); + + static const NSLayoutAttributeBaseline = NSLayoutAttributeLastBaseline; + + final int value; + const NSLayoutAttribute(this.value); + + static NSLayoutAttribute fromValue(int value) => switch (value) { + 1 => NSLayoutAttributeLeft, + 2 => NSLayoutAttributeRight, + 3 => NSLayoutAttributeTop, + 4 => NSLayoutAttributeBottom, + 5 => NSLayoutAttributeLeading, + 6 => NSLayoutAttributeTrailing, + 7 => NSLayoutAttributeWidth, + 8 => NSLayoutAttributeHeight, + 9 => NSLayoutAttributeCenterX, + 10 => NSLayoutAttributeCenterY, + 11 => NSLayoutAttributeLastBaseline, + 12 => NSLayoutAttributeFirstBaseline, + 13 => NSLayoutAttributeLeftMargin, + 14 => NSLayoutAttributeRightMargin, + 15 => NSLayoutAttributeTopMargin, + 16 => NSLayoutAttributeBottomMargin, + 17 => NSLayoutAttributeLeadingMargin, + 18 => NSLayoutAttributeTrailingMargin, + 19 => NSLayoutAttributeCenterXWithinMargins, + 20 => NSLayoutAttributeCenterYWithinMargins, + 0 => NSLayoutAttributeNotAnAttribute, + _ => throw ArgumentError("Unknown value for NSLayoutAttribute: $value"), + }; + + @override + String toString() { + if (this == NSLayoutAttributeLastBaseline) + return "NSLayoutAttribute.NSLayoutAttributeLastBaseline, NSLayoutAttribute.NSLayoutAttributeBaseline"; + return super.toString(); + } +} + +enum NSLayoutRelation { + NSLayoutRelationLessThanOrEqual(-1), + NSLayoutRelationEqual(0), + NSLayoutRelationGreaterThanOrEqual(1); + + final int value; + const NSLayoutRelation(this.value); + + static NSLayoutRelation fromValue(int value) => switch (value) { + -1 => NSLayoutRelationLessThanOrEqual, + 0 => NSLayoutRelationEqual, + 1 => NSLayoutRelationGreaterThanOrEqual, + _ => throw ArgumentError("Unknown value for NSLayoutRelation: $value"), + }; +} + +late final _sel_constraintWithItem_attribute_relatedBy_toItem_attribute_multiplier_constant_ = + objc.registerName( + "constraintWithItem:attribute:relatedBy:toItem:attribute:multiplier:constant:"); +final _objc_msgSend_419 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Long, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Double, + ffi.Double)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer, + int, + double, + double)>(); +late final _sel_priority = objc.registerName("priority"); +late final _sel_setPriority_ = objc.registerName("setPriority:"); +late final _sel_shouldBeArchived = objc.registerName("shouldBeArchived"); +late final _sel_setShouldBeArchived_ = + objc.registerName("setShouldBeArchived:"); +late final _sel_firstItem = objc.registerName("firstItem"); +late final _sel_secondItem = objc.registerName("secondItem"); +late final _sel_firstAttribute = objc.registerName("firstAttribute"); +final _objc_msgSend_420 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_secondAttribute = objc.registerName("secondAttribute"); + +/// NSLayoutAnchor +class NSLayoutAnchor extends objc.NSObject { + NSLayoutAnchor._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSLayoutAnchor] that points to the same underlying object as [other]. + NSLayoutAnchor.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSLayoutAnchor] that wraps the given raw object pointer. + NSLayoutAnchor.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSLayoutAnchor]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSLayoutAnchor); + } + + /// constraintEqualToAnchor: + NSLayoutConstraint constraintEqualToAnchor_(NSLayoutAnchor anchor) { + final _ret = _objc_msgSend_421( + this.pointer, _sel_constraintEqualToAnchor_, anchor.pointer); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintGreaterThanOrEqualToAnchor: + NSLayoutConstraint constraintGreaterThanOrEqualToAnchor_( + NSLayoutAnchor anchor) { + final _ret = _objc_msgSend_421(this.pointer, + _sel_constraintGreaterThanOrEqualToAnchor_, anchor.pointer); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintLessThanOrEqualToAnchor: + NSLayoutConstraint constraintLessThanOrEqualToAnchor_(NSLayoutAnchor anchor) { + final _ret = _objc_msgSend_421( + this.pointer, _sel_constraintLessThanOrEqualToAnchor_, anchor.pointer); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintEqualToAnchor:constant: + NSLayoutConstraint constraintEqualToAnchor_constant_( + NSLayoutAnchor anchor, double c) { + final _ret = _objc_msgSend_422(this.pointer, + _sel_constraintEqualToAnchor_constant_, anchor.pointer, c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintGreaterThanOrEqualToAnchor:constant: + NSLayoutConstraint constraintGreaterThanOrEqualToAnchor_constant_( + NSLayoutAnchor anchor, double c) { + final _ret = _objc_msgSend_422(this.pointer, + _sel_constraintGreaterThanOrEqualToAnchor_constant_, anchor.pointer, c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// constraintLessThanOrEqualToAnchor:constant: + NSLayoutConstraint constraintLessThanOrEqualToAnchor_constant_( + NSLayoutAnchor anchor, double c) { + final _ret = _objc_msgSend_422(this.pointer, + _sel_constraintLessThanOrEqualToAnchor_constant_, anchor.pointer, c); + return NSLayoutConstraint.castFromPointer(_ret, + retain: true, release: true); + } + + /// name + objc.NSString get name { + final _ret = _objc_msgSend_77(this.pointer, _sel_name); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// item + objc.ObjCObjectBase? get item { + final _ret = _objc_msgSend_2(this.pointer, _sel_item); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// hasAmbiguousLayout + bool get hasAmbiguousLayout { + return _objc_msgSend_5(this.pointer, _sel_hasAmbiguousLayout); + } + + /// constraintsAffectingLayout + objc.NSArray get constraintsAffectingLayout { + final _ret = + _objc_msgSend_14(this.pointer, _sel_constraintsAffectingLayout); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSLayoutAnchor init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSLayoutAnchor.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSLayoutAnchor new1() { + final _ret = _objc_msgSend_18(_class_NSLayoutAnchor, _sel_new); + return NSLayoutAnchor.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSLayoutAnchor allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSLayoutAnchor, _sel_allocWithZone_, zone); + return NSLayoutAnchor.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSLayoutAnchor alloc() { + final _ret = _objc_msgSend_18(_class_NSLayoutAnchor, _sel_alloc); + return NSLayoutAnchor.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSLayoutAnchor = objc.getClass("NSLayoutAnchor"); +late final _sel_constraintEqualToAnchor_ = + objc.registerName("constraintEqualToAnchor:"); +final _objc_msgSend_421 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_constraintGreaterThanOrEqualToAnchor_ = + objc.registerName("constraintGreaterThanOrEqualToAnchor:"); +late final _sel_constraintLessThanOrEqualToAnchor_ = + objc.registerName("constraintLessThanOrEqualToAnchor:"); +late final _sel_constraintEqualToAnchor_constant_ = + objc.registerName("constraintEqualToAnchor:constant:"); +final _objc_msgSend_422 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double)>(); +late final _sel_constraintGreaterThanOrEqualToAnchor_constant_ = + objc.registerName("constraintGreaterThanOrEqualToAnchor:constant:"); +late final _sel_constraintLessThanOrEqualToAnchor_constant_ = + objc.registerName("constraintLessThanOrEqualToAnchor:constant:"); +late final _sel_item = objc.registerName("item"); +late final _sel_hasAmbiguousLayout = objc.registerName("hasAmbiguousLayout"); +late final _sel_constraintsAffectingLayout = + objc.registerName("constraintsAffectingLayout"); +late final _sel_firstAnchor = objc.registerName("firstAnchor"); +final _objc_msgSend_423 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_secondAnchor = objc.registerName("secondAnchor"); +final _objc_msgSend_424 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_relation = objc.registerName("relation"); +final _objc_msgSend_425 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_multiplier = objc.registerName("multiplier"); +late final _sel_constant = objc.registerName("constant"); +late final _sel_setConstant_ = objc.registerName("setConstant:"); +late final _sel_isActive = objc.registerName("isActive"); +late final _sel_setActive_ = objc.registerName("setActive:"); +late final _sel_activateConstraints_ = + objc.registerName("activateConstraints:"); +final _objc_msgSend_426 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_deactivateConstraints_ = + objc.registerName("deactivateConstraints:"); +late final _sel_constraintEqualToConstant_ = + objc.registerName("constraintEqualToConstant:"); +final _objc_msgSend_427 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_constraintGreaterThanOrEqualToConstant_ = + objc.registerName("constraintGreaterThanOrEqualToConstant:"); +late final _sel_constraintLessThanOrEqualToConstant_ = + objc.registerName("constraintLessThanOrEqualToConstant:"); +late final _sel_constraintEqualToAnchor_multiplier_ = + objc.registerName("constraintEqualToAnchor:multiplier:"); +final _objc_msgSend_428 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double)>(); +late final _sel_constraintGreaterThanOrEqualToAnchor_multiplier_ = + objc.registerName("constraintGreaterThanOrEqualToAnchor:multiplier:"); +late final _sel_constraintLessThanOrEqualToAnchor_multiplier_ = + objc.registerName("constraintLessThanOrEqualToAnchor:multiplier:"); +late final _sel_constraintEqualToAnchor_multiplier_constant_ = + objc.registerName("constraintEqualToAnchor:multiplier:constant:"); +final _objc_msgSend_429 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Double)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + double)>(); +late final _sel_constraintGreaterThanOrEqualToAnchor_multiplier_constant_ = objc + .registerName("constraintGreaterThanOrEqualToAnchor:multiplier:constant:"); +late final _sel_constraintLessThanOrEqualToAnchor_multiplier_constant_ = + objc.registerName("constraintLessThanOrEqualToAnchor:multiplier:constant:"); +late final _sel_anchorWithOffsetToAnchor_ = + objc.registerName("anchorWithOffsetToAnchor:"); +final _objc_msgSend_430 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_leadingAnchor = objc.registerName("leadingAnchor"); +final _objc_msgSend_431 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_trailingAnchor = objc.registerName("trailingAnchor"); +late final _sel_leftAnchor = objc.registerName("leftAnchor"); +late final _sel_rightAnchor = objc.registerName("rightAnchor"); + +/// NSLayoutYAxisAnchor +class NSLayoutYAxisAnchor extends NSLayoutAnchor { + NSLayoutYAxisAnchor._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSLayoutYAxisAnchor] that points to the same underlying object as [other]. + NSLayoutYAxisAnchor.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSLayoutYAxisAnchor] that wraps the given raw object pointer. + NSLayoutYAxisAnchor.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSLayoutYAxisAnchor]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSLayoutYAxisAnchor); + } + + /// anchorWithOffsetToAnchor: + NSLayoutDimension anchorWithOffsetToAnchor_(NSLayoutYAxisAnchor otherAnchor) { + final _ret = _objc_msgSend_432( + this.pointer, _sel_anchorWithOffsetToAnchor_, otherAnchor.pointer); + return NSLayoutDimension.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSLayoutYAxisAnchor init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSLayoutYAxisAnchor.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static NSLayoutYAxisAnchor new1() { + final _ret = _objc_msgSend_18(_class_NSLayoutYAxisAnchor, _sel_new); + return NSLayoutYAxisAnchor.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static NSLayoutYAxisAnchor allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSLayoutYAxisAnchor, _sel_allocWithZone_, zone); + return NSLayoutYAxisAnchor.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static NSLayoutYAxisAnchor alloc() { + final _ret = _objc_msgSend_18(_class_NSLayoutYAxisAnchor, _sel_alloc); + return NSLayoutYAxisAnchor.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_NSLayoutYAxisAnchor = objc.getClass("NSLayoutYAxisAnchor"); +final _objc_msgSend_432 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_topAnchor = objc.registerName("topAnchor"); +final _objc_msgSend_433 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_bottomAnchor = objc.registerName("bottomAnchor"); +late final _sel_widthAnchor = objc.registerName("widthAnchor"); +final _objc_msgSend_434 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_heightAnchor = objc.registerName("heightAnchor"); +late final _sel_centerXAnchor = objc.registerName("centerXAnchor"); +late final _sel_centerYAnchor = objc.registerName("centerYAnchor"); +late final _sel_contentLayoutGuide = objc.registerName("contentLayoutGuide"); +final _objc_msgSend_435 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_frameLayoutGuide = objc.registerName("frameLayoutGuide"); +late final _sel_isDirectionalLockEnabled = + objc.registerName("isDirectionalLockEnabled"); +late final _sel_setDirectionalLockEnabled_ = + objc.registerName("setDirectionalLockEnabled:"); +late final _sel_bounces = objc.registerName("bounces"); +late final _sel_setBounces_ = objc.registerName("setBounces:"); +late final _sel_bouncesHorizontally = objc.registerName("bouncesHorizontally"); +late final _sel_setBouncesHorizontally_ = + objc.registerName("setBouncesHorizontally:"); +late final _sel_bouncesVertically = objc.registerName("bouncesVertically"); +late final _sel_setBouncesVertically_ = + objc.registerName("setBouncesVertically:"); +late final _sel_alwaysBounceVertical = + objc.registerName("alwaysBounceVertical"); +late final _sel_setAlwaysBounceVertical_ = + objc.registerName("setAlwaysBounceVertical:"); +late final _sel_alwaysBounceHorizontal = + objc.registerName("alwaysBounceHorizontal"); +late final _sel_setAlwaysBounceHorizontal_ = + objc.registerName("setAlwaysBounceHorizontal:"); +late final _sel_isPagingEnabled = objc.registerName("isPagingEnabled"); +late final _sel_setPagingEnabled_ = objc.registerName("setPagingEnabled:"); +late final _sel_isScrollEnabled = objc.registerName("isScrollEnabled"); +late final _sel_setScrollEnabled_ = objc.registerName("setScrollEnabled:"); +late final _sel_transfersHorizontalScrollingToParent = + objc.registerName("transfersHorizontalScrollingToParent"); +late final _sel_setTransfersHorizontalScrollingToParent_ = + objc.registerName("setTransfersHorizontalScrollingToParent:"); +late final _sel_transfersVerticalScrollingToParent = + objc.registerName("transfersVerticalScrollingToParent"); +late final _sel_setTransfersVerticalScrollingToParent_ = + objc.registerName("setTransfersVerticalScrollingToParent:"); +late final _sel_showsVerticalScrollIndicator = + objc.registerName("showsVerticalScrollIndicator"); +late final _sel_setShowsVerticalScrollIndicator_ = + objc.registerName("setShowsVerticalScrollIndicator:"); +late final _sel_showsHorizontalScrollIndicator = + objc.registerName("showsHorizontalScrollIndicator"); +late final _sel_setShowsHorizontalScrollIndicator_ = + objc.registerName("setShowsHorizontalScrollIndicator:"); + +enum UIScrollViewIndicatorStyle { + UIScrollViewIndicatorStyleDefault(0), + UIScrollViewIndicatorStyleBlack(1), + UIScrollViewIndicatorStyleWhite(2); + + final int value; + const UIScrollViewIndicatorStyle(this.value); + + static UIScrollViewIndicatorStyle fromValue(int value) => switch (value) { + 0 => UIScrollViewIndicatorStyleDefault, + 1 => UIScrollViewIndicatorStyleBlack, + 2 => UIScrollViewIndicatorStyleWhite, + _ => throw ArgumentError( + "Unknown value for UIScrollViewIndicatorStyle: $value"), + }; +} + +late final _sel_indicatorStyle = objc.registerName("indicatorStyle"); +final _objc_msgSend_436 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setIndicatorStyle_ = objc.registerName("setIndicatorStyle:"); +final _objc_msgSend_437 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_verticalScrollIndicatorInsets = + objc.registerName("verticalScrollIndicatorInsets"); +late final _sel_setVerticalScrollIndicatorInsets_ = + objc.registerName("setVerticalScrollIndicatorInsets:"); +late final _sel_horizontalScrollIndicatorInsets = + objc.registerName("horizontalScrollIndicatorInsets"); +late final _sel_setHorizontalScrollIndicatorInsets_ = + objc.registerName("setHorizontalScrollIndicatorInsets:"); +late final _sel_scrollIndicatorInsets = + objc.registerName("scrollIndicatorInsets"); +late final _sel_setScrollIndicatorInsets_ = + objc.registerName("setScrollIndicatorInsets:"); +late final _sel_decelerationRate = objc.registerName("decelerationRate"); +late final _sel_setDecelerationRate_ = + objc.registerName("setDecelerationRate:"); + +enum UIScrollViewIndexDisplayMode { + UIScrollViewIndexDisplayModeAutomatic(0), + UIScrollViewIndexDisplayModeAlwaysHidden(1); + + final int value; + const UIScrollViewIndexDisplayMode(this.value); + + static UIScrollViewIndexDisplayMode fromValue(int value) => switch (value) { + 0 => UIScrollViewIndexDisplayModeAutomatic, + 1 => UIScrollViewIndexDisplayModeAlwaysHidden, + _ => throw ArgumentError( + "Unknown value for UIScrollViewIndexDisplayMode: $value"), + }; +} + +late final _sel_indexDisplayMode = objc.registerName("indexDisplayMode"); +final _objc_msgSend_438 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setIndexDisplayMode_ = + objc.registerName("setIndexDisplayMode:"); +final _objc_msgSend_439 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_setContentOffset_animated_ = + objc.registerName("setContentOffset:animated:"); +final _objc_msgSend_440 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGPoint, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGPoint, bool)>(); +late final _sel_scrollRectToVisible_animated_ = + objc.registerName("scrollRectToVisible:animated:"); +final _objc_msgSend_441 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGRect, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGRect, bool)>(); +late final _sel_flashScrollIndicators = + objc.registerName("flashScrollIndicators"); +late final _sel_withScrollIndicatorsShownForContentOffsetChanges_ = + objc.registerName("withScrollIndicatorsShownForContentOffsetChanges:"); +final _objc_msgSend_442 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isTracking = objc.registerName("isTracking"); +late final _sel_isDragging = objc.registerName("isDragging"); +late final _sel_isDecelerating = objc.registerName("isDecelerating"); +late final _sel_isScrollAnimating = objc.registerName("isScrollAnimating"); +late final _sel_delaysContentTouches = + objc.registerName("delaysContentTouches"); +late final _sel_setDelaysContentTouches_ = + objc.registerName("setDelaysContentTouches:"); +late final _sel_canCancelContentTouches = + objc.registerName("canCancelContentTouches"); +late final _sel_setCanCancelContentTouches_ = + objc.registerName("setCanCancelContentTouches:"); +late final _sel_touchesShouldBegin_withEvent_inContentView_ = + objc.registerName("touchesShouldBegin:withEvent:inContentView:"); +final _objc_msgSend_443 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_touchesShouldCancelInContentView_ = + objc.registerName("touchesShouldCancelInContentView:"); +final _objc_msgSend_444 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_minimumZoomScale = objc.registerName("minimumZoomScale"); +late final _sel_setMinimumZoomScale_ = + objc.registerName("setMinimumZoomScale:"); +late final _sel_maximumZoomScale = objc.registerName("maximumZoomScale"); +late final _sel_setMaximumZoomScale_ = + objc.registerName("setMaximumZoomScale:"); +late final _sel_zoomScale = objc.registerName("zoomScale"); +late final _sel_setZoomScale_ = objc.registerName("setZoomScale:"); +late final _sel_setZoomScale_animated_ = + objc.registerName("setZoomScale:animated:"); +final _objc_msgSend_445 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Double, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, double, bool)>(); +late final _sel_zoomToRect_animated_ = + objc.registerName("zoomToRect:animated:"); +late final _sel_bouncesZoom = objc.registerName("bouncesZoom"); +late final _sel_setBouncesZoom_ = objc.registerName("setBouncesZoom:"); +late final _sel_isZooming = objc.registerName("isZooming"); +late final _sel_isZoomBouncing = objc.registerName("isZoomBouncing"); +late final _sel_isZoomAnimating = objc.registerName("isZoomAnimating"); +late final _sel_scrollsToTop = objc.registerName("scrollsToTop"); +late final _sel_setScrollsToTop_ = objc.registerName("setScrollsToTop:"); +late final _sel_stopScrollingAndZooming = + objc.registerName("stopScrollingAndZooming"); + +/// UIPanGestureRecognizer +class UIPanGestureRecognizer extends UIGestureRecognizer { + UIPanGestureRecognizer._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIPanGestureRecognizer] that points to the same underlying object as [other]. + UIPanGestureRecognizer.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIPanGestureRecognizer] that wraps the given raw object pointer. + UIPanGestureRecognizer.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIPanGestureRecognizer]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIPanGestureRecognizer); + } + + /// minimumNumberOfTouches + int get minimumNumberOfTouches { + return _objc_msgSend_42(this.pointer, _sel_minimumNumberOfTouches); + } + + /// setMinimumNumberOfTouches: + set minimumNumberOfTouches(int value) { + return _objc_msgSend_369( + this.pointer, _sel_setMinimumNumberOfTouches_, value); + } + + /// maximumNumberOfTouches + int get maximumNumberOfTouches { + return _objc_msgSend_42(this.pointer, _sel_maximumNumberOfTouches); + } + + /// setMaximumNumberOfTouches: + set maximumNumberOfTouches(int value) { + return _objc_msgSend_369( + this.pointer, _sel_setMaximumNumberOfTouches_, value); + } + + /// translationInView: + void translationInView_(ffi.Pointer stret, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_126Stret(stret, this.pointer, _sel_translationInView_, + view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_126(this.pointer, _sel_translationInView_, + view?.pointer ?? ffi.nullptr); + } + + /// setTranslation:inView: + void setTranslation_inView_(CGPoint translation, UIView? view) { + _objc_msgSend_446(this.pointer, _sel_setTranslation_inView_, translation, + view?.pointer ?? ffi.nullptr); + } + + /// velocityInView: + void velocityInView_(ffi.Pointer stret, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_126Stret(stret, this.pointer, _sel_velocityInView_, + view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_126( + this.pointer, _sel_velocityInView_, view?.pointer ?? ffi.nullptr); + } + + /// allowedScrollTypesMask + UIScrollTypeMask get allowedScrollTypesMask { + final _ret = _objc_msgSend_447(this.pointer, _sel_allowedScrollTypesMask); + return UIScrollTypeMask.fromValue(_ret); + } + + /// setAllowedScrollTypesMask: + set allowedScrollTypesMask(UIScrollTypeMask value) { + return _objc_msgSend_448( + this.pointer, _sel_setAllowedScrollTypesMask_, value.value); + } + + /// initWithTarget:action: + UIPanGestureRecognizer initWithTarget_action_( + objc.ObjCObjectBase? target, ffi.Pointer action) { + final _ret = _objc_msgSend_119(this.pointer, _sel_initWithTarget_action_, + target?.pointer ?? ffi.nullptr, action); + return UIPanGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UIPanGestureRecognizer init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIPanGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithCoder: + UIPanGestureRecognizer? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIPanGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIPanGestureRecognizer new1() { + final _ret = _objc_msgSend_18(_class_UIPanGestureRecognizer, _sel_new); + return UIPanGestureRecognizer.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIPanGestureRecognizer allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIPanGestureRecognizer, _sel_allocWithZone_, zone); + return UIPanGestureRecognizer.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIPanGestureRecognizer alloc() { + final _ret = _objc_msgSend_18(_class_UIPanGestureRecognizer, _sel_alloc); + return UIPanGestureRecognizer.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIPanGestureRecognizer = + objc.getClass("UIPanGestureRecognizer"); +late final _sel_minimumNumberOfTouches = + objc.registerName("minimumNumberOfTouches"); +late final _sel_setMinimumNumberOfTouches_ = + objc.registerName("setMinimumNumberOfTouches:"); +late final _sel_maximumNumberOfTouches = + objc.registerName("maximumNumberOfTouches"); +late final _sel_setMaximumNumberOfTouches_ = + objc.registerName("setMaximumNumberOfTouches:"); +late final _sel_translationInView_ = objc.registerName("translationInView:"); +late final _sel_setTranslation_inView_ = + objc.registerName("setTranslation:inView:"); +final _objc_msgSend_446 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>(); +late final _sel_velocityInView_ = objc.registerName("velocityInView:"); + +enum UIScrollTypeMask { + UIScrollTypeMaskDiscrete(1), + UIScrollTypeMaskContinuous(2), + UIScrollTypeMaskAll(3); + + final int value; + const UIScrollTypeMask(this.value); + + static UIScrollTypeMask fromValue(int value) => switch (value) { + 1 => UIScrollTypeMaskDiscrete, + 2 => UIScrollTypeMaskContinuous, + 3 => UIScrollTypeMaskAll, + _ => throw ArgumentError("Unknown value for UIScrollTypeMask: $value"), + }; +} + +late final _sel_allowedScrollTypesMask = + objc.registerName("allowedScrollTypesMask"); +final _objc_msgSend_447 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAllowedScrollTypesMask_ = + objc.registerName("setAllowedScrollTypesMask:"); +final _objc_msgSend_448 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_panGestureRecognizer = + objc.registerName("panGestureRecognizer"); +final _objc_msgSend_449 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UIPinchGestureRecognizer +class UIPinchGestureRecognizer extends UIGestureRecognizer { + UIPinchGestureRecognizer._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIPinchGestureRecognizer] that points to the same underlying object as [other]. + UIPinchGestureRecognizer.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIPinchGestureRecognizer] that wraps the given raw object pointer. + UIPinchGestureRecognizer.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIPinchGestureRecognizer]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIPinchGestureRecognizer); + } + + /// scale + double get scale { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_scale) + : _objc_msgSend_11(this.pointer, _sel_scale); + } + + /// setScale: + set scale(double value) { + return _objc_msgSend_26(this.pointer, _sel_setScale_, value); + } + + /// velocity + double get velocity { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_velocity) + : _objc_msgSend_11(this.pointer, _sel_velocity); + } + + /// initWithTarget:action: + UIPinchGestureRecognizer initWithTarget_action_( + objc.ObjCObjectBase? target, ffi.Pointer action) { + final _ret = _objc_msgSend_119(this.pointer, _sel_initWithTarget_action_, + target?.pointer ?? ffi.nullptr, action); + return UIPinchGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UIPinchGestureRecognizer init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIPinchGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithCoder: + UIPinchGestureRecognizer? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIPinchGestureRecognizer.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIPinchGestureRecognizer new1() { + final _ret = _objc_msgSend_18(_class_UIPinchGestureRecognizer, _sel_new); + return UIPinchGestureRecognizer.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIPinchGestureRecognizer allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIPinchGestureRecognizer, _sel_allocWithZone_, zone); + return UIPinchGestureRecognizer.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIPinchGestureRecognizer alloc() { + final _ret = _objc_msgSend_18(_class_UIPinchGestureRecognizer, _sel_alloc); + return UIPinchGestureRecognizer.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIPinchGestureRecognizer = + objc.getClass("UIPinchGestureRecognizer"); +late final _sel_velocity = objc.registerName("velocity"); +late final _sel_pinchGestureRecognizer = + objc.registerName("pinchGestureRecognizer"); +final _objc_msgSend_450 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_directionalPressGestureRecognizer = + objc.registerName("directionalPressGestureRecognizer"); +final _objc_msgSend_451 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIScrollViewKeyboardDismissMode { + UIScrollViewKeyboardDismissModeNone(0), + UIScrollViewKeyboardDismissModeOnDrag(1), + UIScrollViewKeyboardDismissModeInteractive(2), + UIScrollViewKeyboardDismissModeOnDragWithAccessory(3), + UIScrollViewKeyboardDismissModeInteractiveWithAccessory(4); + + final int value; + const UIScrollViewKeyboardDismissMode(this.value); + + static UIScrollViewKeyboardDismissMode fromValue(int value) => + switch (value) { + 0 => UIScrollViewKeyboardDismissModeNone, + 1 => UIScrollViewKeyboardDismissModeOnDrag, + 2 => UIScrollViewKeyboardDismissModeInteractive, + 3 => UIScrollViewKeyboardDismissModeOnDragWithAccessory, + 4 => UIScrollViewKeyboardDismissModeInteractiveWithAccessory, + _ => throw ArgumentError( + "Unknown value for UIScrollViewKeyboardDismissMode: $value"), + }; +} + +late final _sel_keyboardDismissMode = objc.registerName("keyboardDismissMode"); +final _objc_msgSend_452 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setKeyboardDismissMode_ = + objc.registerName("setKeyboardDismissMode:"); +final _objc_msgSend_453 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +/// UIRefreshControl +class UIRefreshControl extends UIControl { + UIRefreshControl._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIRefreshControl] that points to the same underlying object as [other]. + UIRefreshControl.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIRefreshControl] that wraps the given raw object pointer. + UIRefreshControl.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIRefreshControl]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIRefreshControl); + } + + /// init + UIRefreshControl init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIRefreshControl.castFromPointer(_ret, retain: true, release: true); + } + + /// isRefreshing + bool get refreshing { + return _objc_msgSend_5(this.pointer, _sel_isRefreshing); + } + + /// tintColor + UIColor get tintColor { + final _ret = _objc_msgSend_345(this.pointer, _sel_tintColor); + return UIColor.castFromPointer(_ret, retain: true, release: true); + } + + /// setTintColor: + set tintColor(UIColor value) { + return _objc_msgSend_454(this.pointer, _sel_setTintColor_, value.pointer); + } + + /// attributedTitle + NSAttributedString? get attributedTitle { + final _ret = _objc_msgSend_455(this.pointer, _sel_attributedTitle); + return _ret.address == 0 + ? null + : NSAttributedString.castFromPointer(_ret, retain: true, release: true); + } + + /// setAttributedTitle: + set attributedTitle(NSAttributedString? value) { + return _objc_msgSend_456( + this.pointer, _sel_setAttributedTitle_, value?.pointer ?? ffi.nullptr); + } + + /// beginRefreshing + void beginRefreshing() { + _objc_msgSend_4(this.pointer, _sel_beginRefreshing); + } + + /// endRefreshing + void endRefreshing() { + _objc_msgSend_4(this.pointer, _sel_endRefreshing); + } + + /// initWithFrame: + UIRefreshControl initWithFrame_(CGRect frame) { + final _ret = _objc_msgSend_54(this.pointer, _sel_initWithFrame_, frame); + return UIRefreshControl.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIRefreshControl? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIRefreshControl.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithFrame:primaryAction: + UIRefreshControl initWithFrame_primaryAction_( + CGRect frame, UIAction? primaryAction) { + final _ret = _objc_msgSend_459( + this.pointer, + _sel_initWithFrame_primaryAction_, + frame, + primaryAction?.pointer ?? ffi.nullptr); + return UIRefreshControl.castFromPointer(_ret, retain: true, release: true); + } + + /// layerClass + static objc.ObjCObjectBase getLayerClass() { + final _ret = _objc_msgSend_18(_class_UIRefreshControl, _sel_layerClass); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_( + UISemanticContentAttribute attribute) { + final _ret = _objc_msgSend_111( + _class_UIRefreshControl, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_, + attribute.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute:relativeToLayoutDirection: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_( + UISemanticContentAttribute semanticContentAttribute, + UIUserInterfaceLayoutDirection layoutDirection) { + final _ret = _objc_msgSend_112( + _class_UIRefreshControl, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_, + semanticContentAttribute.value, + layoutDirection.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// new + static UIRefreshControl new1() { + final _ret = _objc_msgSend_18(_class_UIRefreshControl, _sel_new); + return UIRefreshControl.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIRefreshControl allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIRefreshControl, _sel_allocWithZone_, zone); + return UIRefreshControl.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIRefreshControl alloc() { + final _ret = _objc_msgSend_18(_class_UIRefreshControl, _sel_alloc); + return UIRefreshControl.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIRefreshControl = objc.getClass("UIRefreshControl"); +late final _sel_isRefreshing = objc.registerName("isRefreshing"); +late final _sel_tintColor = objc.registerName("tintColor"); +late final _sel_setTintColor_ = objc.registerName("setTintColor:"); +final _objc_msgSend_454 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_attributedTitle = objc.registerName("attributedTitle"); +final _objc_msgSend_455 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAttributedTitle_ = objc.registerName("setAttributedTitle:"); +final _objc_msgSend_456 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_beginRefreshing = objc.registerName("beginRefreshing"); +late final _sel_endRefreshing = objc.registerName("endRefreshing"); + +/// UIControl +class UIControl extends UIView { + UIControl._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIControl] that points to the same underlying object as [other]. + UIControl.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIControl] that wraps the given raw object pointer. + UIControl.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIControl]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIControl); + } + + /// initWithFrame: + UIControl initWithFrame_(CGRect frame) { + final _ret = _objc_msgSend_54(this.pointer, _sel_initWithFrame_, frame); + return UIControl.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIControl? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIControl.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithFrame:primaryAction: + UIControl initWithFrame_primaryAction_( + CGRect frame, UIAction? primaryAction) { + final _ret = _objc_msgSend_459( + this.pointer, + _sel_initWithFrame_primaryAction_, + frame, + primaryAction?.pointer ?? ffi.nullptr); + return UIControl.castFromPointer(_ret, retain: true, release: true); + } + + /// isEnabled + bool get enabled { + return _objc_msgSend_5(this.pointer, _sel_isEnabled); + } + + /// setEnabled: + set enabled(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setEnabled_, value); + } + + /// isSelected + bool get selected { + return _objc_msgSend_5(this.pointer, _sel_isSelected); + } + + /// setSelected: + set selected(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setSelected_, value); + } + + /// isHighlighted + bool get highlighted { + return _objc_msgSend_5(this.pointer, _sel_isHighlighted); + } + + /// setHighlighted: + set highlighted(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setHighlighted_, value); + } + + /// contentVerticalAlignment + UIControlContentVerticalAlignment get contentVerticalAlignment { + final _ret = _objc_msgSend_460(this.pointer, _sel_contentVerticalAlignment); + return UIControlContentVerticalAlignment.fromValue(_ret); + } + + /// setContentVerticalAlignment: + set contentVerticalAlignment(UIControlContentVerticalAlignment value) { + return _objc_msgSend_461( + this.pointer, _sel_setContentVerticalAlignment_, value.value); + } + + /// contentHorizontalAlignment + UIControlContentHorizontalAlignment get contentHorizontalAlignment { + final _ret = + _objc_msgSend_462(this.pointer, _sel_contentHorizontalAlignment); + return UIControlContentHorizontalAlignment.fromValue(_ret); + } + + /// setContentHorizontalAlignment: + set contentHorizontalAlignment(UIControlContentHorizontalAlignment value) { + return _objc_msgSend_463( + this.pointer, _sel_setContentHorizontalAlignment_, value.value); + } + + /// effectiveContentHorizontalAlignment + UIControlContentHorizontalAlignment get effectiveContentHorizontalAlignment { + final _ret = _objc_msgSend_462( + this.pointer, _sel_effectiveContentHorizontalAlignment); + return UIControlContentHorizontalAlignment.fromValue(_ret); + } + + /// state + UIControlState get state { + final _ret = _objc_msgSend_464(this.pointer, _sel_state); + return UIControlState.fromValue(_ret); + } + + /// isTracking + bool get tracking { + return _objc_msgSend_5(this.pointer, _sel_isTracking); + } + + /// isTouchInside + bool get touchInside { + return _objc_msgSend_5(this.pointer, _sel_isTouchInside); + } + + /// beginTrackingWithTouch:withEvent: + bool beginTrackingWithTouch_withEvent_(UITouch touch, UIEvent? event) { + return _objc_msgSend_471( + this.pointer, + _sel_beginTrackingWithTouch_withEvent_, + touch.pointer, + event?.pointer ?? ffi.nullptr); + } + + /// continueTrackingWithTouch:withEvent: + bool continueTrackingWithTouch_withEvent_(UITouch touch, UIEvent? event) { + return _objc_msgSend_471( + this.pointer, + _sel_continueTrackingWithTouch_withEvent_, + touch.pointer, + event?.pointer ?? ffi.nullptr); + } + + /// endTrackingWithTouch:withEvent: + void endTrackingWithTouch_withEvent_(UITouch? touch, UIEvent? event) { + _objc_msgSend_472(this.pointer, _sel_endTrackingWithTouch_withEvent_, + touch?.pointer ?? ffi.nullptr, event?.pointer ?? ffi.nullptr); + } + + /// cancelTrackingWithEvent: + void cancelTrackingWithEvent_(UIEvent? event) { + _objc_msgSend_131(this.pointer, _sel_cancelTrackingWithEvent_, + event?.pointer ?? ffi.nullptr); + } + + /// addTarget:action:forControlEvents: + void addTarget_action_forControlEvents_(objc.ObjCObjectBase? target, + ffi.Pointer action, UIControlEvents controlEvents) { + _objc_msgSend_473(this.pointer, _sel_addTarget_action_forControlEvents_, + target?.pointer ?? ffi.nullptr, action, controlEvents.value); + } + + /// removeTarget:action:forControlEvents: + void removeTarget_action_forControlEvents_(objc.ObjCObjectBase? target, + ffi.Pointer action, UIControlEvents controlEvents) { + _objc_msgSend_473(this.pointer, _sel_removeTarget_action_forControlEvents_, + target?.pointer ?? ffi.nullptr, action, controlEvents.value); + } + + /// addAction:forControlEvents: + void addAction_forControlEvents_( + UIAction action, UIControlEvents controlEvents) { + _objc_msgSend_474(this.pointer, _sel_addAction_forControlEvents_, + action.pointer, controlEvents.value); + } + + /// removeAction:forControlEvents: + void removeAction_forControlEvents_( + UIAction action, UIControlEvents controlEvents) { + _objc_msgSend_474(this.pointer, _sel_removeAction_forControlEvents_, + action.pointer, controlEvents.value); + } + + /// removeActionForIdentifier:forControlEvents: + void removeActionForIdentifier_forControlEvents_( + objc.NSString actionIdentifier, UIControlEvents controlEvents) { + _objc_msgSend_475( + this.pointer, + _sel_removeActionForIdentifier_forControlEvents_, + actionIdentifier.pointer, + controlEvents.value); + } + + /// performPrimaryAction + void performPrimaryAction() { + _objc_msgSend_4(this.pointer, _sel_performPrimaryAction); + } + + /// allTargets + objc.NSSet get allTargets { + final _ret = _objc_msgSend_118(this.pointer, _sel_allTargets); + return objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// allControlEvents + UIControlEvents get allControlEvents { + final _ret = _objc_msgSend_476(this.pointer, _sel_allControlEvents); + return UIControlEvents.fromValue(_ret); + } + + /// actionsForTarget:forControlEvent: + objc.NSArray? actionsForTarget_forControlEvent_( + objc.ObjCObjectBase? target, UIControlEvents controlEvent) { + final _ret = _objc_msgSend_477( + this.pointer, + _sel_actionsForTarget_forControlEvent_, + target?.pointer ?? ffi.nullptr, + controlEvent.value); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// enumerateEventHandlers: + void enumerateEventHandlers_( + ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool + iterator) { + _objc_msgSend_478( + this.pointer, _sel_enumerateEventHandlers_, iterator.pointer); + } + + /// sendAction:to:forEvent: + void sendAction_to_forEvent_(ffi.Pointer action, + objc.ObjCObjectBase? target, UIEvent? event) { + _objc_msgSend_479(this.pointer, _sel_sendAction_to_forEvent_, action, + target?.pointer ?? ffi.nullptr, event?.pointer ?? ffi.nullptr); + } + + /// sendAction: + void sendAction_(UIAction action) { + _objc_msgSend_480(this.pointer, _sel_sendAction_, action.pointer); + } + + /// sendActionsForControlEvents: + void sendActionsForControlEvents_(UIControlEvents controlEvents) { + _objc_msgSend_481( + this.pointer, _sel_sendActionsForControlEvents_, controlEvents.value); + } + + /// contextMenuInteraction + UIContextMenuInteraction? get contextMenuInteraction { + final _ret = _objc_msgSend_492(this.pointer, _sel_contextMenuInteraction); + return _ret.address == 0 + ? null + : UIContextMenuInteraction.castFromPointer(_ret, + retain: true, release: true); + } + + /// isContextMenuInteractionEnabled + bool get contextMenuInteractionEnabled { + return _objc_msgSend_5(this.pointer, _sel_isContextMenuInteractionEnabled); + } + + /// setContextMenuInteractionEnabled: + set contextMenuInteractionEnabled(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setContextMenuInteractionEnabled_, value); + } + + /// showsMenuAsPrimaryAction + bool get showsMenuAsPrimaryAction { + return _objc_msgSend_5(this.pointer, _sel_showsMenuAsPrimaryAction); + } + + /// setShowsMenuAsPrimaryAction: + set showsMenuAsPrimaryAction(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setShowsMenuAsPrimaryAction_, value); + } + + /// menuAttachmentPointForConfiguration: + void menuAttachmentPointForConfiguration_( + ffi.Pointer stret, UIContextMenuConfiguration configuration) { + objc.useMsgSendVariants + ? _objc_msgSend_497Stret(stret, this.pointer, + _sel_menuAttachmentPointForConfiguration_, configuration.pointer) + : stret.ref = _objc_msgSend_497(this.pointer, + _sel_menuAttachmentPointForConfiguration_, configuration.pointer); + } + + /// toolTip + objc.NSString? get toolTip { + final _ret = _objc_msgSend_29(this.pointer, _sel_toolTip); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setToolTip: + set toolTip(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setToolTip_, value?.pointer ?? ffi.nullptr); + } + + /// toolTipInteraction + UIToolTipInteraction? get toolTipInteraction { + final _ret = _objc_msgSend_498(this.pointer, _sel_toolTipInteraction); + return _ret.address == 0 + ? null + : UIToolTipInteraction.castFromPointer(_ret, + retain: true, release: true); + } + + /// isSymbolAnimationEnabled + bool get symbolAnimationEnabled { + return _objc_msgSend_5(this.pointer, _sel_isSymbolAnimationEnabled); + } + + /// setSymbolAnimationEnabled: + set symbolAnimationEnabled(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setSymbolAnimationEnabled_, value); + } + + /// layerClass + static objc.ObjCObjectBase getLayerClass() { + final _ret = _objc_msgSend_18(_class_UIControl, _sel_layerClass); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_( + UISemanticContentAttribute attribute) { + final _ret = _objc_msgSend_111( + _class_UIControl, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_, + attribute.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// userInterfaceLayoutDirectionForSemanticContentAttribute:relativeToLayoutDirection: + static UIUserInterfaceLayoutDirection + userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_( + UISemanticContentAttribute semanticContentAttribute, + UIUserInterfaceLayoutDirection layoutDirection) { + final _ret = _objc_msgSend_112( + _class_UIControl, + _sel_userInterfaceLayoutDirectionForSemanticContentAttribute_relativeToLayoutDirection_, + semanticContentAttribute.value, + layoutDirection.value); + return UIUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// init + UIControl init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIControl.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIControl new1() { + final _ret = _objc_msgSend_18(_class_UIControl, _sel_new); + return UIControl.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UIControl allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIControl, _sel_allocWithZone_, zone); + return UIControl.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIControl alloc() { + final _ret = _objc_msgSend_18(_class_UIControl, _sel_alloc); + return UIControl.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIControl = objc.getClass("UIControl"); + +/// UIAction +class UIAction extends UIMenuElement { + UIAction._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIAction] that points to the same underlying object as [other]. + UIAction.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIAction] that wraps the given raw object pointer. + UIAction.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIAction]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIAction); + } + + /// title + objc.NSString get title { + final _ret = _objc_msgSend_77(this.pointer, _sel_title); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTitle: + set title(objc.NSString value) { + return _objc_msgSend_78(this.pointer, _sel_setTitle_, value.pointer); + } + + /// image + UIImage? get image { + final _ret = _objc_msgSend_356(this.pointer, _sel_image); + return _ret.address == 0 + ? null + : UIImage.castFromPointer(_ret, retain: true, release: true); + } + + /// setImage: + set image(UIImage? value) { + return _objc_msgSend_360( + this.pointer, _sel_setImage_, value?.pointer ?? ffi.nullptr); + } + + /// discoverabilityTitle + objc.NSString? get discoverabilityTitle { + final _ret = _objc_msgSend_29(this.pointer, _sel_discoverabilityTitle); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setDiscoverabilityTitle: + set discoverabilityTitle(objc.NSString? value) { + return _objc_msgSend_103(this.pointer, _sel_setDiscoverabilityTitle_, + value?.pointer ?? ffi.nullptr); + } + + /// identifier + objc.NSString get identifier { + final _ret = _objc_msgSend_77(this.pointer, _sel_identifier); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// attributes + UIMenuElementAttributes get attributes { + final _ret = _objc_msgSend_362(this.pointer, _sel_attributes); + return UIMenuElementAttributes.fromValue(_ret); + } + + /// setAttributes: + set attributes(UIMenuElementAttributes value) { + return _objc_msgSend_363(this.pointer, _sel_setAttributes_, value.value); + } + + /// state + UIMenuElementState get state { + final _ret = _objc_msgSend_364(this.pointer, _sel_state); + return UIMenuElementState.fromValue(_ret); + } + + /// setState: + set state(UIMenuElementState value) { + return _objc_msgSend_365(this.pointer, _sel_setState_, value.value); + } + + /// sender + objc.ObjCObjectBase? get sender { + final _ret = _objc_msgSend_2(this.pointer, _sel_sender); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// actionWithHandler: + static UIAction actionWithHandler_(ObjCBlock_ffiVoid_UIAction handler) { + final _ret = _objc_msgSend_457( + _class_UIAction, _sel_actionWithHandler_, handler.pointer); + return UIAction.castFromPointer(_ret, retain: true, release: true); + } + + /// actionWithTitle:image:identifier:handler: + static UIAction actionWithTitle_image_identifier_handler_( + objc.NSString title, + UIImage? image, + objc.NSString? identifier, + ObjCBlock_ffiVoid_UIAction handler) { + final _ret = _objc_msgSend_458( + _class_UIAction, + _sel_actionWithTitle_image_identifier_handler_, + title.pointer, + image?.pointer ?? ffi.nullptr, + identifier?.pointer ?? ffi.nullptr, + handler.pointer); + return UIAction.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIAction init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIAction.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIAction new1() { + final _ret = _objc_msgSend_18(_class_UIAction, _sel_new); + return UIAction.castFromPointer(_ret, retain: false, release: true); + } + + /// initWithCoder: + UIAction? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIAction.castFromPointer(_ret, retain: true, release: true); + } + + /// allocWithZone: + static UIAction allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIAction, _sel_allocWithZone_, zone); + return UIAction.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIAction alloc() { + final _ret = _objc_msgSend_18(_class_UIAction, _sel_alloc); + return UIAction.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIAction = objc.getClass("UIAction"); +void _ObjCBlock_ffiVoid_UIAction_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_UIAction_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_UIAction extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_UIAction._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_UIAction castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_UIAction._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_UIAction.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_UIAction_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_UIAction.fromFunction(void Function(UIAction) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_UIAction_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn( + UIAction.castFromPointer(arg0, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_UIAction.listener(void Function(UIAction) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_UIAction( + objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_UIAction_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn( + UIAction.castFromPointer(arg0, + retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(UIAction arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0.pointer); +} + +late final _sel_actionWithHandler_ = objc.registerName("actionWithHandler:"); +final _objc_msgSend_457 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_actionWithTitle_image_identifier_handler_ = + objc.registerName("actionWithTitle:image:identifier:handler:"); +final _objc_msgSend_458 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithFrame_primaryAction_ = + objc.registerName("initWithFrame:primaryAction:"); +final _objc_msgSend_459 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +late final _sel_isSelected = objc.registerName("isSelected"); +late final _sel_setSelected_ = objc.registerName("setSelected:"); +late final _sel_isHighlighted = objc.registerName("isHighlighted"); +late final _sel_setHighlighted_ = objc.registerName("setHighlighted:"); + +enum UIControlContentVerticalAlignment { + UIControlContentVerticalAlignmentCenter(0), + UIControlContentVerticalAlignmentTop(1), + UIControlContentVerticalAlignmentBottom(2), + UIControlContentVerticalAlignmentFill(3); + + final int value; + const UIControlContentVerticalAlignment(this.value); + + static UIControlContentVerticalAlignment fromValue(int value) => + switch (value) { + 0 => UIControlContentVerticalAlignmentCenter, + 1 => UIControlContentVerticalAlignmentTop, + 2 => UIControlContentVerticalAlignmentBottom, + 3 => UIControlContentVerticalAlignmentFill, + _ => throw ArgumentError( + "Unknown value for UIControlContentVerticalAlignment: $value"), + }; +} + +late final _sel_contentVerticalAlignment = + objc.registerName("contentVerticalAlignment"); +final _objc_msgSend_460 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setContentVerticalAlignment_ = + objc.registerName("setContentVerticalAlignment:"); +final _objc_msgSend_461 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +enum UIControlContentHorizontalAlignment { + UIControlContentHorizontalAlignmentCenter(0), + UIControlContentHorizontalAlignmentLeft(1), + UIControlContentHorizontalAlignmentRight(2), + UIControlContentHorizontalAlignmentFill(3), + UIControlContentHorizontalAlignmentLeading(4), + UIControlContentHorizontalAlignmentTrailing(5); + + final int value; + const UIControlContentHorizontalAlignment(this.value); + + static UIControlContentHorizontalAlignment fromValue(int value) => + switch (value) { + 0 => UIControlContentHorizontalAlignmentCenter, + 1 => UIControlContentHorizontalAlignmentLeft, + 2 => UIControlContentHorizontalAlignmentRight, + 3 => UIControlContentHorizontalAlignmentFill, + 4 => UIControlContentHorizontalAlignmentLeading, + 5 => UIControlContentHorizontalAlignmentTrailing, + _ => throw ArgumentError( + "Unknown value for UIControlContentHorizontalAlignment: $value"), + }; +} + +late final _sel_contentHorizontalAlignment = + objc.registerName("contentHorizontalAlignment"); +final _objc_msgSend_462 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setContentHorizontalAlignment_ = + objc.registerName("setContentHorizontalAlignment:"); +final _objc_msgSend_463 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_effectiveContentHorizontalAlignment = + objc.registerName("effectiveContentHorizontalAlignment"); + +enum UIControlState { + UIControlStateNormal(0), + UIControlStateHighlighted(1), + UIControlStateDisabled(2), + UIControlStateSelected(4), + UIControlStateFocused(8), + UIControlStateApplication(16711680), + UIControlStateReserved(4278190080); + + final int value; + const UIControlState(this.value); + + static UIControlState fromValue(int value) => switch (value) { + 0 => UIControlStateNormal, + 1 => UIControlStateHighlighted, + 2 => UIControlStateDisabled, + 4 => UIControlStateSelected, + 8 => UIControlStateFocused, + 16711680 => UIControlStateApplication, + 4278190080 => UIControlStateReserved, + _ => throw ArgumentError("Unknown value for UIControlState: $value"), + }; +} + +final _objc_msgSend_464 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isTouchInside = objc.registerName("isTouchInside"); + +/// UITouch +class UITouch extends objc.NSObject { + UITouch._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UITouch] that points to the same underlying object as [other]. + UITouch.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UITouch] that wraps the given raw object pointer. + UITouch.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UITouch]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UITouch); + } + + /// timestamp + double get timestamp { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_timestamp) + : _objc_msgSend_11(this.pointer, _sel_timestamp); + } + + /// phase + UITouchPhase get phase { + final _ret = _objc_msgSend_465(this.pointer, _sel_phase); + return UITouchPhase.fromValue(_ret); + } + + /// tapCount + int get tapCount { + return _objc_msgSend_42(this.pointer, _sel_tapCount); + } + + /// type + UITouchType get type { + final _ret = _objc_msgSend_466(this.pointer, _sel_type); + return UITouchType.fromValue(_ret); + } + + /// majorRadius + double get majorRadius { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_majorRadius) + : _objc_msgSend_11(this.pointer, _sel_majorRadius); + } + + /// majorRadiusTolerance + double get majorRadiusTolerance { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_majorRadiusTolerance) + : _objc_msgSend_11(this.pointer, _sel_majorRadiusTolerance); + } + + /// window + UIWindow? get window { + final _ret = _objc_msgSend_381(this.pointer, _sel_window); + return _ret.address == 0 + ? null + : UIWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// view + UIView? get view { + final _ret = _objc_msgSend_123(this.pointer, _sel_view); + return _ret.address == 0 + ? null + : UIView.castFromPointer(_ret, retain: true, release: true); + } + + /// gestureRecognizers + objc.NSArray? get gestureRecognizers { + final _ret = _objc_msgSend_90(this.pointer, _sel_gestureRecognizers); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// locationInView: + void locationInView_(ffi.Pointer stret, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_126Stret(stret, this.pointer, _sel_locationInView_, + view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_126( + this.pointer, _sel_locationInView_, view?.pointer ?? ffi.nullptr); + } + + /// previousLocationInView: + void previousLocationInView_(ffi.Pointer stret, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_126Stret(stret, this.pointer, + _sel_previousLocationInView_, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_126(this.pointer, + _sel_previousLocationInView_, view?.pointer ?? ffi.nullptr); + } + + /// preciseLocationInView: + void preciseLocationInView_(ffi.Pointer stret, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_126Stret(stret, this.pointer, + _sel_preciseLocationInView_, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_126(this.pointer, + _sel_preciseLocationInView_, view?.pointer ?? ffi.nullptr); + } + + /// precisePreviousLocationInView: + void precisePreviousLocationInView_( + ffi.Pointer stret, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_126Stret(stret, this.pointer, + _sel_precisePreviousLocationInView_, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_126(this.pointer, + _sel_precisePreviousLocationInView_, view?.pointer ?? ffi.nullptr); + } + + /// force + double get force { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_force) + : _objc_msgSend_11(this.pointer, _sel_force); + } + + /// maximumPossibleForce + double get maximumPossibleForce { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_maximumPossibleForce) + : _objc_msgSend_11(this.pointer, _sel_maximumPossibleForce); + } + + /// azimuthAngleInView: + double azimuthAngleInView_(UIView? view) { + return objc.useMsgSendVariants + ? _objc_msgSend_467Fpret(this.pointer, _sel_azimuthAngleInView_, + view?.pointer ?? ffi.nullptr) + : _objc_msgSend_467(this.pointer, _sel_azimuthAngleInView_, + view?.pointer ?? ffi.nullptr); + } + + /// azimuthUnitVectorInView: + void azimuthUnitVectorInView_(ffi.Pointer stret, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_468Stret(stret, this.pointer, + _sel_azimuthUnitVectorInView_, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_468(this.pointer, + _sel_azimuthUnitVectorInView_, view?.pointer ?? ffi.nullptr); + } + + /// altitudeAngle + double get altitudeAngle { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_altitudeAngle) + : _objc_msgSend_11(this.pointer, _sel_altitudeAngle); + } + + /// estimationUpdateIndex + objc.NSNumber? get estimationUpdateIndex { + final _ret = _objc_msgSend_469(this.pointer, _sel_estimationUpdateIndex); + return _ret.address == 0 + ? null + : objc.NSNumber.castFromPointer(_ret, retain: true, release: true); + } + + /// estimatedProperties + UITouchProperties get estimatedProperties { + final _ret = _objc_msgSend_470(this.pointer, _sel_estimatedProperties); + return UITouchProperties.fromValue(_ret); + } + + /// estimatedPropertiesExpectingUpdates + UITouchProperties get estimatedPropertiesExpectingUpdates { + final _ret = _objc_msgSend_470( + this.pointer, _sel_estimatedPropertiesExpectingUpdates); + return UITouchProperties.fromValue(_ret); + } + + /// rollAngle + double get rollAngle { + return objc.useMsgSendVariants + ? _objc_msgSend_11Fpret(this.pointer, _sel_rollAngle) + : _objc_msgSend_11(this.pointer, _sel_rollAngle); + } + + /// init + UITouch init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UITouch.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UITouch new1() { + final _ret = _objc_msgSend_18(_class_UITouch, _sel_new); + return UITouch.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static UITouch allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UITouch, _sel_allocWithZone_, zone); + return UITouch.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UITouch alloc() { + final _ret = _objc_msgSend_18(_class_UITouch, _sel_alloc); + return UITouch.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UITouch = objc.getClass("UITouch"); + +enum UITouchPhase { + UITouchPhaseBegan(0), + UITouchPhaseMoved(1), + UITouchPhaseStationary(2), + UITouchPhaseEnded(3), + UITouchPhaseCancelled(4), + UITouchPhaseRegionEntered(5), + UITouchPhaseRegionMoved(6), + UITouchPhaseRegionExited(7); + + final int value; + const UITouchPhase(this.value); + + static UITouchPhase fromValue(int value) => switch (value) { + 0 => UITouchPhaseBegan, + 1 => UITouchPhaseMoved, + 2 => UITouchPhaseStationary, + 3 => UITouchPhaseEnded, + 4 => UITouchPhaseCancelled, + 5 => UITouchPhaseRegionEntered, + 6 => UITouchPhaseRegionMoved, + 7 => UITouchPhaseRegionExited, + _ => throw ArgumentError("Unknown value for UITouchPhase: $value"), + }; +} + +late final _sel_phase = objc.registerName("phase"); +final _objc_msgSend_465 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_tapCount = objc.registerName("tapCount"); + +enum UITouchType { + UITouchTypeDirect(0), + UITouchTypeIndirect(1), + UITouchTypePencil(2), + UITouchTypeIndirectPointer(3); + + static const UITouchTypeStylus = UITouchTypePencil; + + final int value; + const UITouchType(this.value); + + static UITouchType fromValue(int value) => switch (value) { + 0 => UITouchTypeDirect, + 1 => UITouchTypeIndirect, + 2 => UITouchTypePencil, + 3 => UITouchTypeIndirectPointer, + _ => throw ArgumentError("Unknown value for UITouchType: $value"), + }; + + @override + String toString() { + if (this == UITouchTypePencil) + return "UITouchType.UITouchTypePencil, UITouchType.UITouchTypeStylus"; + return super.toString(); + } +} + +final _objc_msgSend_466 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_majorRadius = objc.registerName("majorRadius"); +late final _sel_majorRadiusTolerance = + objc.registerName("majorRadiusTolerance"); +late final _sel_window = objc.registerName("window"); +late final _sel_gestureRecognizers = objc.registerName("gestureRecognizers"); +late final _sel_previousLocationInView_ = + objc.registerName("previousLocationInView:"); +late final _sel_preciseLocationInView_ = + objc.registerName("preciseLocationInView:"); +late final _sel_precisePreviousLocationInView_ = + objc.registerName("precisePreviousLocationInView:"); +late final _sel_force = objc.registerName("force"); +late final _sel_maximumPossibleForce = + objc.registerName("maximumPossibleForce"); +late final _sel_azimuthAngleInView_ = objc.registerName("azimuthAngleInView:"); +final _objc_msgSend_467 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_467Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +final class CGVector extends ffi.Struct { + @ffi.Double() + external double dx; + + @ffi.Double() + external double dy; +} + +late final _sel_azimuthUnitVectorInView_ = + objc.registerName("azimuthUnitVectorInView:"); +final _objc_msgSend_468 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGVector Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGVector Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_468Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_altitudeAngle = objc.registerName("altitudeAngle"); +late final _sel_estimationUpdateIndex = + objc.registerName("estimationUpdateIndex"); +final _objc_msgSend_469 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UITouchProperties { + UITouchPropertyForce(1), + UITouchPropertyAzimuth(2), + UITouchPropertyAltitude(4), + UITouchPropertyLocation(8), + UITouchPropertyRoll(16); + + final int value; + const UITouchProperties(this.value); + + static UITouchProperties fromValue(int value) => switch (value) { + 1 => UITouchPropertyForce, + 2 => UITouchPropertyAzimuth, + 4 => UITouchPropertyAltitude, + 8 => UITouchPropertyLocation, + 16 => UITouchPropertyRoll, + _ => throw ArgumentError("Unknown value for UITouchProperties: $value"), + }; +} + +late final _sel_estimatedProperties = objc.registerName("estimatedProperties"); +final _objc_msgSend_470 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_estimatedPropertiesExpectingUpdates = + objc.registerName("estimatedPropertiesExpectingUpdates"); +late final _sel_rollAngle = objc.registerName("rollAngle"); +late final _sel_beginTrackingWithTouch_withEvent_ = + objc.registerName("beginTrackingWithTouch:withEvent:"); +final _objc_msgSend_471 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_continueTrackingWithTouch_withEvent_ = + objc.registerName("continueTrackingWithTouch:withEvent:"); +late final _sel_endTrackingWithTouch_withEvent_ = + objc.registerName("endTrackingWithTouch:withEvent:"); +final _objc_msgSend_472 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_cancelTrackingWithEvent_ = + objc.registerName("cancelTrackingWithEvent:"); + +enum UIControlEvents { + UIControlEventTouchDown(1), + UIControlEventTouchDownRepeat(2), + UIControlEventTouchDragInside(4), + UIControlEventTouchDragOutside(8), + UIControlEventTouchDragEnter(16), + UIControlEventTouchDragExit(32), + UIControlEventTouchUpInside(64), + UIControlEventTouchUpOutside(128), + UIControlEventTouchCancel(256), + UIControlEventValueChanged(4096), + UIControlEventPrimaryActionTriggered(8192), + UIControlEventMenuActionTriggered(16384), + UIControlEventEditingDidBegin(65536), + UIControlEventEditingChanged(131072), + UIControlEventEditingDidEnd(262144), + UIControlEventEditingDidEndOnExit(524288), + UIControlEventAllTouchEvents(4095), + UIControlEventAllEditingEvents(983040), + UIControlEventApplicationReserved(251658240), + UIControlEventSystemReserved(4026531840), + UIControlEventAllEvents(4294967295); + + final int value; + const UIControlEvents(this.value); + + static UIControlEvents fromValue(int value) => switch (value) { + 1 => UIControlEventTouchDown, + 2 => UIControlEventTouchDownRepeat, + 4 => UIControlEventTouchDragInside, + 8 => UIControlEventTouchDragOutside, + 16 => UIControlEventTouchDragEnter, + 32 => UIControlEventTouchDragExit, + 64 => UIControlEventTouchUpInside, + 128 => UIControlEventTouchUpOutside, + 256 => UIControlEventTouchCancel, + 4096 => UIControlEventValueChanged, + 8192 => UIControlEventPrimaryActionTriggered, + 16384 => UIControlEventMenuActionTriggered, + 65536 => UIControlEventEditingDidBegin, + 131072 => UIControlEventEditingChanged, + 262144 => UIControlEventEditingDidEnd, + 524288 => UIControlEventEditingDidEndOnExit, + 4095 => UIControlEventAllTouchEvents, + 983040 => UIControlEventAllEditingEvents, + 251658240 => UIControlEventApplicationReserved, + 4026531840 => UIControlEventSystemReserved, + 4294967295 => UIControlEventAllEvents, + _ => throw ArgumentError("Unknown value for UIControlEvents: $value"), + }; +} + +late final _sel_addTarget_action_forControlEvents_ = + objc.registerName("addTarget:action:forControlEvents:"); +final _objc_msgSend_473 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_removeTarget_action_forControlEvents_ = + objc.registerName("removeTarget:action:forControlEvents:"); +late final _sel_addAction_forControlEvents_ = + objc.registerName("addAction:forControlEvents:"); +final _objc_msgSend_474 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_removeAction_forControlEvents_ = + objc.registerName("removeAction:forControlEvents:"); +late final _sel_removeActionForIdentifier_forControlEvents_ = + objc.registerName("removeActionForIdentifier:forControlEvents:"); +final _objc_msgSend_475 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_performPrimaryAction = + objc.registerName("performPrimaryAction"); +late final _sel_allTargets = objc.registerName("allTargets"); +late final _sel_allControlEvents = objc.registerName("allControlEvents"); +final _objc_msgSend_476 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_actionsForTarget_forControlEvent_ = + objc.registerName("actionsForTarget:forControlEvent:"); +final _objc_msgSend_477 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +void + _ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + int arg3, + ffi.Pointer arg4) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.UnsignedLong arg3, + ffi.Pointer arg4)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>()(arg0, arg1, arg2, arg3, arg4); +void + _ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + int arg3, + ffi.Pointer arg4) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer))(arg0, arg1, arg2, arg3, arg4); + +class ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool + ._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.UnsignedLong arg3, + ffi.Pointer arg4)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool.fromFunction(void Function(UIAction?, objc.ObjCObjectBase?, ffi.Pointer, UIControlEvents, ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2, int arg3, ffi.Pointer arg4) => fn( + arg0.address == 0 + ? null + : UIAction.castFromPointer(arg0, retain: true, release: true), + arg1.address == 0 ? null : objc.ObjCObjectBase(arg1, retain: true, release: true), + arg2, + UIControlEvents.fromValue(arg3), + arg4))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool.listener( + void Function( + UIAction?, + objc.ObjCObjectBase?, + ffi.Pointer, + UIControlEvents, + ffi.Pointer) + fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool( + objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable, ffi.Pointer, ffi.Pointer, ffi.Pointer, ffi.UnsignedLong, ffi.Pointer)>.listener(_ObjCBlock_ffiVoid_UIAction_objcObjCObject_objcObjCSelector_UIControlEvents_bool_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + int arg3, + ffi.Pointer arg4) => + fn( + arg0.address == 0 ? null : UIAction.castFromPointer(arg0, retain: false, release: true), + arg1.address == 0 ? null : objc.ObjCObjectBase(arg1, retain: false, release: true), + arg2, + UIControlEvents.fromValue(arg3), + arg4)))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call( + UIAction? arg0, + objc.ObjCObjectBase? arg1, + ffi.Pointer arg2, + UIControlEvents arg3, + ffi.Pointer arg4) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.UnsignedLong arg3, + ffi.Pointer arg4)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>()( + pointer, + arg0?.pointer ?? ffi.nullptr, + arg1?.pointer ?? ffi.nullptr, + arg2, + arg3.value, + arg4); +} + +late final _sel_enumerateEventHandlers_ = + objc.registerName("enumerateEventHandlers:"); +final _objc_msgSend_478 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_sendAction_to_forEvent_ = + objc.registerName("sendAction:to:forEvent:"); +final _objc_msgSend_479 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_sendAction_ = objc.registerName("sendAction:"); +final _objc_msgSend_480 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_sendActionsForControlEvents_ = + objc.registerName("sendActionsForControlEvents:"); +final _objc_msgSend_481 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +/// UIContextMenuInteraction +class UIContextMenuInteraction extends objc.NSObject { + UIContextMenuInteraction._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIContextMenuInteraction] that points to the same underlying object as [other]. + UIContextMenuInteraction.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIContextMenuInteraction] that wraps the given raw object pointer. + UIContextMenuInteraction.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIContextMenuInteraction]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIContextMenuInteraction); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// menuAppearance + UIContextMenuInteractionAppearance get menuAppearance { + final _ret = _objc_msgSend_482(this.pointer, _sel_menuAppearance); + return UIContextMenuInteractionAppearance.fromValue(_ret); + } + + /// initWithDelegate: + UIContextMenuInteraction initWithDelegate_(objc.ObjCObjectBase delegate) { + final _ret = _objc_msgSend_56( + this.pointer, _sel_initWithDelegate_, delegate.pointer); + return UIContextMenuInteraction.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UIContextMenuInteraction init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIContextMenuInteraction.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIContextMenuInteraction new1() { + final _ret = _objc_msgSend_18(_class_UIContextMenuInteraction, _sel_new); + return UIContextMenuInteraction.castFromPointer(_ret, + retain: false, release: true); + } + + /// locationInView: + void locationInView_(ffi.Pointer stret, UIView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_126Stret(stret, this.pointer, _sel_locationInView_, + view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_126( + this.pointer, _sel_locationInView_, view?.pointer ?? ffi.nullptr); + } + + /// updateVisibleMenuWithBlock: + void updateVisibleMenuWithBlock_(ObjCBlock_UIMenu_UIMenu block) { + _objc_msgSend_491( + this.pointer, _sel_updateVisibleMenuWithBlock_, block.pointer); + } + + /// dismissMenu + void dismissMenu() { + _objc_msgSend_4(this.pointer, _sel_dismissMenu); + } + + /// allocWithZone: + static UIContextMenuInteraction allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIContextMenuInteraction, _sel_allocWithZone_, zone); + return UIContextMenuInteraction.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIContextMenuInteraction alloc() { + final _ret = _objc_msgSend_18(_class_UIContextMenuInteraction, _sel_alloc); + return UIContextMenuInteraction.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIContextMenuInteraction = + objc.getClass("UIContextMenuInteraction"); + +enum UIContextMenuInteractionAppearance { + UIContextMenuInteractionAppearanceUnknown(0), + UIContextMenuInteractionAppearanceRich(1), + UIContextMenuInteractionAppearanceCompact(2); + + final int value; + const UIContextMenuInteractionAppearance(this.value); + + static UIContextMenuInteractionAppearance fromValue(int value) => + switch (value) { + 0 => UIContextMenuInteractionAppearanceUnknown, + 1 => UIContextMenuInteractionAppearanceRich, + 2 => UIContextMenuInteractionAppearanceCompact, + _ => throw ArgumentError( + "Unknown value for UIContextMenuInteractionAppearance: $value"), + }; +} + +late final _sel_menuAppearance = objc.registerName("menuAppearance"); +final _objc_msgSend_482 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithDelegate_ = objc.registerName("initWithDelegate:"); +ffi.Pointer _ObjCBlock_UIMenu_UIMenu_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()(arg0); +ffi.Pointer _ObjCBlock_UIMenu_UIMenu_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer))(arg0); + +class ObjCBlock_UIMenu_UIMenu extends objc.ObjCBlockBase { + ObjCBlock_UIMenu_UIMenu._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_UIMenu_UIMenu castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_UIMenu_UIMenu._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIMenu_UIMenu.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_UIMenu_UIMenu_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIMenu_UIMenu.fromFunction(UIMenu Function(UIMenu) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_UIMenu_UIMenu_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => + fn(UIMenu.castFromPointer(arg0, retain: true, release: true)) + .retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + UIMenu call(UIMenu arg0) => UIMenu.castFromPointer( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0.pointer), + retain: false, + release: true); +} + +/// UIMenu +class UIMenu extends UIMenuElement { + UIMenu._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIMenu] that points to the same underlying object as [other]. + UIMenu.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIMenu] that wraps the given raw object pointer. + UIMenu.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIMenu]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_UIMenu); + } + + /// identifier + objc.NSString get identifier { + final _ret = _objc_msgSend_77(this.pointer, _sel_identifier); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// options + UIMenuOptions get options { + final _ret = _objc_msgSend_483(this.pointer, _sel_options); + return UIMenuOptions.fromValue(_ret); + } + + /// preferredElementSize + UIMenuElementSize get preferredElementSize { + final _ret = _objc_msgSend_484(this.pointer, _sel_preferredElementSize); + return UIMenuElementSize.fromValue(_ret); + } + + /// setPreferredElementSize: + set preferredElementSize(UIMenuElementSize value) { + return _objc_msgSend_485( + this.pointer, _sel_setPreferredElementSize_, value.value); + } + + /// children + objc.NSArray get children { + final _ret = _objc_msgSend_14(this.pointer, _sel_children); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// selectedElements + objc.NSArray get selectedElements { + final _ret = _objc_msgSend_14(this.pointer, _sel_selectedElements); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// displayPreferences + UIMenuDisplayPreferences? get displayPreferences { + final _ret = _objc_msgSend_486(this.pointer, _sel_displayPreferences); + return _ret.address == 0 + ? null + : UIMenuDisplayPreferences.castFromPointer(_ret, + retain: true, release: true); + } + + /// setDisplayPreferences: + set displayPreferences(UIMenuDisplayPreferences? value) { + return _objc_msgSend_487(this.pointer, _sel_setDisplayPreferences_, + value?.pointer ?? ffi.nullptr); + } + + /// menuWithChildren: + static UIMenu menuWithChildren_(objc.NSArray children) { + final _ret = _objc_msgSend_488( + _class_UIMenu, _sel_menuWithChildren_, children.pointer); + return UIMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// menuWithTitle:children: + static UIMenu menuWithTitle_children_( + objc.NSString title, objc.NSArray children) { + final _ret = _objc_msgSend_489(_class_UIMenu, _sel_menuWithTitle_children_, + title.pointer, children.pointer); + return UIMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// menuWithTitle:image:identifier:options:children: + static UIMenu menuWithTitle_image_identifier_options_children_( + objc.NSString title, + UIImage? image, + objc.NSString? identifier, + UIMenuOptions options, + objc.NSArray children) { + final _ret = _objc_msgSend_490( + _class_UIMenu, + _sel_menuWithTitle_image_identifier_options_children_, + title.pointer, + image?.pointer ?? ffi.nullptr, + identifier?.pointer ?? ffi.nullptr, + options.value, + children.pointer); + return UIMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + UIMenu? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UIMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIMenu init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static UIMenu new1() { + final _ret = _objc_msgSend_18(_class_UIMenu, _sel_new); + return UIMenu.castFromPointer(_ret, retain: false, release: true); + } + + /// menuByReplacingChildren: + UIMenu menuByReplacingChildren_(objc.NSArray newChildren) { + final _ret = _objc_msgSend_488( + this.pointer, _sel_menuByReplacingChildren_, newChildren.pointer); + return UIMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// allocWithZone: + static UIMenu allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_UIMenu, _sel_allocWithZone_, zone); + return UIMenu.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static UIMenu alloc() { + final _ret = _objc_msgSend_18(_class_UIMenu, _sel_alloc); + return UIMenu.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_UIMenu = objc.getClass("UIMenu"); + +enum UIMenuOptions { + UIMenuOptionsDisplayInline(1), + UIMenuOptionsDestructive(2), + UIMenuOptionsSingleSelection(32), + UIMenuOptionsDisplayAsPalette(128); + + final int value; + const UIMenuOptions(this.value); + + static UIMenuOptions fromValue(int value) => switch (value) { + 1 => UIMenuOptionsDisplayInline, + 2 => UIMenuOptionsDestructive, + 32 => UIMenuOptionsSingleSelection, + 128 => UIMenuOptionsDisplayAsPalette, + _ => throw ArgumentError("Unknown value for UIMenuOptions: $value"), + }; +} + +late final _sel_options = objc.registerName("options"); +final _objc_msgSend_483 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UIMenuElementSize { + UIMenuElementSizeSmall(0), + UIMenuElementSizeMedium(1), + UIMenuElementSizeLarge(2), + UIMenuElementSizeAutomatic(-1); + + final int value; + const UIMenuElementSize(this.value); + + static UIMenuElementSize fromValue(int value) => switch (value) { + 0 => UIMenuElementSizeSmall, + 1 => UIMenuElementSizeMedium, + 2 => UIMenuElementSizeLarge, + -1 => UIMenuElementSizeAutomatic, + _ => throw ArgumentError("Unknown value for UIMenuElementSize: $value"), + }; +} + +late final _sel_preferredElementSize = + objc.registerName("preferredElementSize"); +final _objc_msgSend_484 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setPreferredElementSize_ = + objc.registerName("setPreferredElementSize:"); +final _objc_msgSend_485 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_children = objc.registerName("children"); +late final _sel_selectedElements = objc.registerName("selectedElements"); + +/// UIMenuDisplayPreferences +class UIMenuDisplayPreferences extends objc.NSObject { + UIMenuDisplayPreferences._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIMenuDisplayPreferences] that points to the same underlying object as [other]. + UIMenuDisplayPreferences.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIMenuDisplayPreferences] that wraps the given raw object pointer. + UIMenuDisplayPreferences.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIMenuDisplayPreferences]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIMenuDisplayPreferences); + } + + /// maximumNumberOfTitleLines + int get maximumNumberOfTitleLines { + return _objc_msgSend_48(this.pointer, _sel_maximumNumberOfTitleLines); + } + + /// setMaximumNumberOfTitleLines: + set maximumNumberOfTitleLines(int value) { + return _objc_msgSend_49( + this.pointer, _sel_setMaximumNumberOfTitleLines_, value); + } + + /// init + UIMenuDisplayPreferences init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIMenuDisplayPreferences.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIMenuDisplayPreferences new1() { + final _ret = _objc_msgSend_18(_class_UIMenuDisplayPreferences, _sel_new); + return UIMenuDisplayPreferences.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIMenuDisplayPreferences allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIMenuDisplayPreferences, _sel_allocWithZone_, zone); + return UIMenuDisplayPreferences.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIMenuDisplayPreferences alloc() { + final _ret = _objc_msgSend_18(_class_UIMenuDisplayPreferences, _sel_alloc); + return UIMenuDisplayPreferences.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIMenuDisplayPreferences = + objc.getClass("UIMenuDisplayPreferences"); +late final _sel_maximumNumberOfTitleLines = + objc.registerName("maximumNumberOfTitleLines"); +late final _sel_setMaximumNumberOfTitleLines_ = + objc.registerName("setMaximumNumberOfTitleLines:"); +late final _sel_displayPreferences = objc.registerName("displayPreferences"); +final _objc_msgSend_486 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setDisplayPreferences_ = + objc.registerName("setDisplayPreferences:"); +final _objc_msgSend_487 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_menuWithChildren_ = objc.registerName("menuWithChildren:"); +final _objc_msgSend_488 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_menuWithTitle_children_ = + objc.registerName("menuWithTitle:children:"); +final _objc_msgSend_489 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_menuWithTitle_image_identifier_options_children_ = + objc.registerName("menuWithTitle:image:identifier:options:children:"); +final _objc_msgSend_490 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_menuByReplacingChildren_ = + objc.registerName("menuByReplacingChildren:"); +late final _sel_updateVisibleMenuWithBlock_ = + objc.registerName("updateVisibleMenuWithBlock:"); +final _objc_msgSend_491 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_dismissMenu = objc.registerName("dismissMenu"); +late final _sel_contextMenuInteraction = + objc.registerName("contextMenuInteraction"); +final _objc_msgSend_492 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isContextMenuInteractionEnabled = + objc.registerName("isContextMenuInteractionEnabled"); +late final _sel_setContextMenuInteractionEnabled_ = + objc.registerName("setContextMenuInteractionEnabled:"); +late final _sel_showsMenuAsPrimaryAction = + objc.registerName("showsMenuAsPrimaryAction"); +late final _sel_setShowsMenuAsPrimaryAction_ = + objc.registerName("setShowsMenuAsPrimaryAction:"); + +/// UIContextMenuConfiguration +class UIContextMenuConfiguration extends objc.NSObject { + UIContextMenuConfiguration._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIContextMenuConfiguration] that points to the same underlying object as [other]. + UIContextMenuConfiguration.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIContextMenuConfiguration] that wraps the given raw object pointer. + UIContextMenuConfiguration.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIContextMenuConfiguration]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIContextMenuConfiguration); + } + + /// identifier + objc.ObjCObjectBase get identifier { + final _ret = _objc_msgSend_18(this.pointer, _sel_identifier); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// secondaryItemIdentifiers + objc.NSSet get secondaryItemIdentifiers { + final _ret = _objc_msgSend_118(this.pointer, _sel_secondaryItemIdentifiers); + return objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// setSecondaryItemIdentifiers: + set secondaryItemIdentifiers(objc.NSSet value) { + return _objc_msgSend_493( + this.pointer, _sel_setSecondaryItemIdentifiers_, value.pointer); + } + + /// badgeCount + int get badgeCount { + return _objc_msgSend_48(this.pointer, _sel_badgeCount); + } + + /// setBadgeCount: + set badgeCount(int value) { + return _objc_msgSend_49(this.pointer, _sel_setBadgeCount_, value); + } + + /// preferredMenuElementOrder + UIContextMenuConfigurationElementOrder get preferredMenuElementOrder { + final _ret = + _objc_msgSend_494(this.pointer, _sel_preferredMenuElementOrder); + return UIContextMenuConfigurationElementOrder.fromValue(_ret); + } + + /// setPreferredMenuElementOrder: + set preferredMenuElementOrder(UIContextMenuConfigurationElementOrder value) { + return _objc_msgSend_495( + this.pointer, _sel_setPreferredMenuElementOrder_, value.value); + } + + /// configurationWithIdentifier:previewProvider:actionProvider: + static UIContextMenuConfiguration + configurationWithIdentifier_previewProvider_actionProvider_( + objc.ObjCObjectBase? identifier, + ObjCBlock_UIViewController? previewProvider, + ObjCBlock_UIMenu_NSArray? actionProvider) { + final _ret = _objc_msgSend_496( + _class_UIContextMenuConfiguration, + _sel_configurationWithIdentifier_previewProvider_actionProvider_, + identifier?.pointer ?? ffi.nullptr, + previewProvider?.pointer ?? ffi.nullptr, + actionProvider?.pointer ?? ffi.nullptr); + return UIContextMenuConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UIContextMenuConfiguration init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIContextMenuConfiguration.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIContextMenuConfiguration new1() { + final _ret = _objc_msgSend_18(_class_UIContextMenuConfiguration, _sel_new); + return UIContextMenuConfiguration.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIContextMenuConfiguration allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIContextMenuConfiguration, _sel_allocWithZone_, zone); + return UIContextMenuConfiguration.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIContextMenuConfiguration alloc() { + final _ret = + _objc_msgSend_18(_class_UIContextMenuConfiguration, _sel_alloc); + return UIContextMenuConfiguration.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIContextMenuConfiguration = + objc.getClass("UIContextMenuConfiguration"); +late final _sel_secondaryItemIdentifiers = + objc.registerName("secondaryItemIdentifiers"); +late final _sel_setSecondaryItemIdentifiers_ = + objc.registerName("setSecondaryItemIdentifiers:"); +final _objc_msgSend_493 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_badgeCount = objc.registerName("badgeCount"); +late final _sel_setBadgeCount_ = objc.registerName("setBadgeCount:"); + +enum UIContextMenuConfigurationElementOrder { + UIContextMenuConfigurationElementOrderAutomatic(0), + UIContextMenuConfigurationElementOrderPriority(1), + UIContextMenuConfigurationElementOrderFixed(2); + + final int value; + const UIContextMenuConfigurationElementOrder(this.value); + + static UIContextMenuConfigurationElementOrder fromValue(int value) => + switch (value) { + 0 => UIContextMenuConfigurationElementOrderAutomatic, + 1 => UIContextMenuConfigurationElementOrderPriority, + 2 => UIContextMenuConfigurationElementOrderFixed, + _ => throw ArgumentError( + "Unknown value for UIContextMenuConfigurationElementOrder: $value"), + }; +} + +late final _sel_preferredMenuElementOrder = + objc.registerName("preferredMenuElementOrder"); +final _objc_msgSend_494 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setPreferredMenuElementOrder_ = + objc.registerName("setPreferredMenuElementOrder:"); +final _objc_msgSend_495 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +ffi.Pointer _ObjCBlock_UIViewController_fnPtrTrampoline( + ffi.Pointer block, +) => + block.ref.target + .cast Function()>>() + .asFunction Function()>()(); +ffi.Pointer _ObjCBlock_UIViewController_closureTrampoline( + ffi.Pointer block, +) => + (objc.getBlockClosure(block) as ffi.Pointer Function())(); + +class ObjCBlock_UIViewController extends objc.ObjCBlockBase { + ObjCBlock_UIViewController._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_UIViewController castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_UIViewController._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIViewController.fromFunctionPointer( + ffi.Pointer Function()>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer)>( + _ObjCBlock_UIViewController_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIViewController.fromFunction(UIViewController? Function() fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer)>( + _ObjCBlock_UIViewController_closureTrampoline) + .cast(), + () => fn()?.retainAndReturnPointer() ?? ffi.nullptr)); + static ffi.Pointer? _dartFuncTrampoline; + + UIViewController? call() => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()( + pointer, + ) + .address == + 0 + ? null + : UIViewController.castFromPointer( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()( + pointer, + ), + retain: false, + release: true); +} + +ffi.Pointer _ObjCBlock_UIMenu_NSArray_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()(arg0); +ffi.Pointer _ObjCBlock_UIMenu_NSArray_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer))(arg0); + +class ObjCBlock_UIMenu_NSArray extends objc.ObjCBlockBase { + ObjCBlock_UIMenu_NSArray._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_UIMenu_NSArray castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_UIMenu_NSArray._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIMenu_NSArray.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_UIMenu_NSArray_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIMenu_NSArray.fromFunction(UIMenu? Function(objc.NSArray) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_UIMenu_NSArray_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => + fn(objc.NSArray.castFromPointer(arg0, + retain: true, release: true)) + ?.retainAndReturnPointer() ?? + ffi.nullptr)); + static ffi.Pointer? _dartFuncTrampoline; + + UIMenu? call(objc.NSArray arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction Function(ffi.Pointer, ffi.Pointer)>() + (pointer, arg0.pointer) + .address == + 0 + ? null + : UIMenu.castFromPointer( + pointer.ref.invoke.cast Function(ffi.Pointer block, ffi.Pointer arg0)>>().asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>()(pointer, arg0.pointer), + retain: false, + release: true); +} + +late final _sel_configurationWithIdentifier_previewProvider_actionProvider_ = + objc.registerName( + "configurationWithIdentifier:previewProvider:actionProvider:"); +final _objc_msgSend_496 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_menuAttachmentPointForConfiguration_ = + objc.registerName("menuAttachmentPointForConfiguration:"); +final _objc_msgSend_497 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGPoint Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_497Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_toolTip = objc.registerName("toolTip"); +late final _sel_setToolTip_ = objc.registerName("setToolTip:"); + +/// UIToolTipInteraction +class UIToolTipInteraction extends objc.NSObject { + UIToolTipInteraction._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIToolTipInteraction] that points to the same underlying object as [other]. + UIToolTipInteraction.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIToolTipInteraction] that wraps the given raw object pointer. + UIToolTipInteraction.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIToolTipInteraction]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIToolTipInteraction); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// isEnabled + bool get enabled { + return _objc_msgSend_5(this.pointer, _sel_isEnabled); + } + + /// setEnabled: + set enabled(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setEnabled_, value); + } + + /// defaultToolTip + objc.NSString? get defaultToolTip { + final _ret = _objc_msgSend_29(this.pointer, _sel_defaultToolTip); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setDefaultToolTip: + set defaultToolTip(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setDefaultToolTip_, value?.pointer ?? ffi.nullptr); + } + + /// init + UIToolTipInteraction init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIToolTipInteraction.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithDefaultToolTip: + UIToolTipInteraction initWithDefaultToolTip_(objc.NSString defaultToolTip) { + final _ret = _objc_msgSend_95( + this.pointer, _sel_initWithDefaultToolTip_, defaultToolTip.pointer); + return UIToolTipInteraction.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIToolTipInteraction new1() { + final _ret = _objc_msgSend_18(_class_UIToolTipInteraction, _sel_new); + return UIToolTipInteraction.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIToolTipInteraction allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIToolTipInteraction, _sel_allocWithZone_, zone); + return UIToolTipInteraction.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIToolTipInteraction alloc() { + final _ret = _objc_msgSend_18(_class_UIToolTipInteraction, _sel_alloc); + return UIToolTipInteraction.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIToolTipInteraction = objc.getClass("UIToolTipInteraction"); +late final _sel_defaultToolTip = objc.registerName("defaultToolTip"); +late final _sel_setDefaultToolTip_ = objc.registerName("setDefaultToolTip:"); +late final _sel_initWithDefaultToolTip_ = + objc.registerName("initWithDefaultToolTip:"); +late final _sel_toolTipInteraction = objc.registerName("toolTipInteraction"); +final _objc_msgSend_498 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isSymbolAnimationEnabled = + objc.registerName("isSymbolAnimationEnabled"); +late final _sel_setSymbolAnimationEnabled_ = + objc.registerName("setSymbolAnimationEnabled:"); +late final _sel_refreshControl = objc.registerName("refreshControl"); +final _objc_msgSend_499 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setRefreshControl_ = objc.registerName("setRefreshControl:"); +final _objc_msgSend_500 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_allowsKeyboardScrolling = + objc.registerName("allowsKeyboardScrolling"); +late final _sel_setAllowsKeyboardScrolling_ = + objc.registerName("setAllowsKeyboardScrolling:"); + +enum NSDirectionalRectEdge { + NSDirectionalRectEdgeNone(0), + NSDirectionalRectEdgeTop(1), + NSDirectionalRectEdgeLeading(2), + NSDirectionalRectEdgeBottom(4), + NSDirectionalRectEdgeTrailing(8), + NSDirectionalRectEdgeAll(15); + + final int value; + const NSDirectionalRectEdge(this.value); + + static NSDirectionalRectEdge fromValue(int value) => switch (value) { + 0 => NSDirectionalRectEdgeNone, + 1 => NSDirectionalRectEdgeTop, + 2 => NSDirectionalRectEdgeLeading, + 4 => NSDirectionalRectEdgeBottom, + 8 => NSDirectionalRectEdgeTrailing, + 15 => NSDirectionalRectEdgeAll, + _ => throw ArgumentError( + "Unknown value for NSDirectionalRectEdge: $value"), + }; +} + +late final _sel_setContentScrollView_forEdge_ = + objc.registerName("setContentScrollView:forEdge:"); +final _objc_msgSend_501 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_contentScrollViewForEdge_ = + objc.registerName("contentScrollViewForEdge:"); +final _objc_msgSend_502 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_preferredContentSize = + objc.registerName("preferredContentSize"); +late final _sel_setPreferredContentSize_ = + objc.registerName("setPreferredContentSize:"); + +enum UIStatusBarStyle { + UIStatusBarStyleDefault(0), + UIStatusBarStyleLightContent(1), + UIStatusBarStyleDarkContent(3), + UIStatusBarStyleBlackOpaque(2); + + static const UIStatusBarStyleBlackTranslucent = UIStatusBarStyleLightContent; + + final int value; + const UIStatusBarStyle(this.value); + + static UIStatusBarStyle fromValue(int value) => switch (value) { + 0 => UIStatusBarStyleDefault, + 1 => UIStatusBarStyleLightContent, + 3 => UIStatusBarStyleDarkContent, + 2 => UIStatusBarStyleBlackOpaque, + _ => throw ArgumentError("Unknown value for UIStatusBarStyle: $value"), + }; + + @override + String toString() { + if (this == UIStatusBarStyleLightContent) + return "UIStatusBarStyle.UIStatusBarStyleLightContent, UIStatusBarStyle.UIStatusBarStyleBlackTranslucent"; + return super.toString(); + } +} + +late final _sel_preferredStatusBarStyle = + objc.registerName("preferredStatusBarStyle"); +final _objc_msgSend_503 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_prefersStatusBarHidden = + objc.registerName("prefersStatusBarHidden"); + +enum UIStatusBarAnimation { + UIStatusBarAnimationNone(0), + UIStatusBarAnimationFade(1), + UIStatusBarAnimationSlide(2); + + final int value; + const UIStatusBarAnimation(this.value); + + static UIStatusBarAnimation fromValue(int value) => switch (value) { + 0 => UIStatusBarAnimationNone, + 1 => UIStatusBarAnimationFade, + 2 => UIStatusBarAnimationSlide, + _ => + throw ArgumentError("Unknown value for UIStatusBarAnimation: $value"), + }; +} + +late final _sel_preferredStatusBarUpdateAnimation = + objc.registerName("preferredStatusBarUpdateAnimation"); +final _objc_msgSend_504 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setNeedsStatusBarAppearanceUpdate = + objc.registerName("setNeedsStatusBarAppearanceUpdate"); +late final _sel_targetViewControllerForAction_sender_ = + objc.registerName("targetViewControllerForAction:sender:"); +final _objc_msgSend_505 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_showViewController_sender_ = + objc.registerName("showViewController:sender:"); +final _objc_msgSend_506 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_showDetailViewController_sender_ = + objc.registerName("showDetailViewController:sender:"); +late final _sel_preferredUserInterfaceStyle = + objc.registerName("preferredUserInterfaceStyle"); +late final _sel_setNeedsUserInterfaceAppearanceUpdate = + objc.registerName("setNeedsUserInterfaceAppearanceUpdate"); +late final _sel_overrideUserInterfaceStyle = + objc.registerName("overrideUserInterfaceStyle"); +late final _sel_setOverrideUserInterfaceStyle_ = + objc.registerName("setOverrideUserInterfaceStyle:"); +final _objc_msgSend_507 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_instantiateInitialViewController = + objc.registerName("instantiateInitialViewController"); +ffi.Pointer + _ObjCBlock_UIViewController_NSCoder_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()(arg0); +ffi.Pointer + _ObjCBlock_UIViewController_NSCoder_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer))(arg0); + +class ObjCBlock_UIViewController_NSCoder extends objc.ObjCBlockBase { + ObjCBlock_UIViewController_NSCoder._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_UIViewController_NSCoder castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_UIViewController_NSCoder._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIViewController_NSCoder.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_UIViewController_NSCoder_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIViewController_NSCoder.fromFunction( + UIViewController? Function(objc.NSCoder) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_UIViewController_NSCoder_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => + fn(objc.NSCoder.castFromPointer(arg0, retain: true, release: true)) + ?.retainAndReturnPointer() ?? + ffi.nullptr)); + static ffi.Pointer? _dartFuncTrampoline; + + UIViewController? call(objc.NSCoder arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction Function(ffi.Pointer, ffi.Pointer)>() + (pointer, arg0.pointer) + .address == + 0 + ? null + : UIViewController.castFromPointer( + pointer.ref.invoke.cast Function(ffi.Pointer block, ffi.Pointer arg0)>>().asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>()(pointer, arg0.pointer), + retain: false, + release: true); +} + +late final _sel_instantiateInitialViewControllerWithCreator_ = + objc.registerName("instantiateInitialViewControllerWithCreator:"); +final _objc_msgSend_508 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_instantiateViewControllerWithIdentifier_ = + objc.registerName("instantiateViewControllerWithIdentifier:"); +final _objc_msgSend_509 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_instantiateViewControllerWithIdentifier_creator_ = + objc.registerName("instantiateViewControllerWithIdentifier:creator:"); +final _objc_msgSend_510 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_setStoryboard_ = objc.registerName("setStoryboard:"); +final _objc_msgSend_511 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_512 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_persistentIdentifier = + objc.registerName("persistentIdentifier"); + +/// NSUserActivity +class NSUserActivity extends objc.NSObject { + NSUserActivity._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSUserActivity] that points to the same underlying object as [other]. + NSUserActivity.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSUserActivity] that wraps the given raw object pointer. + NSUserActivity.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSUserActivity]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSUserActivity); + } + + /// initWithActivityType: + NSUserActivity initWithActivityType_(objc.NSString activityType) { + final _ret = _objc_msgSend_95( + this.pointer, _sel_initWithActivityType_, activityType.pointer); + return NSUserActivity.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSUserActivity init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSUserActivity.castFromPointer(_ret, retain: true, release: true); + } + + /// activityType + objc.NSString get activityType { + final _ret = _objc_msgSend_77(this.pointer, _sel_activityType); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// title + objc.NSString? get title { + final _ret = _objc_msgSend_29(this.pointer, _sel_title); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTitle: + set title(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setTitle_, value?.pointer ?? ffi.nullptr); + } + + /// userInfo + objc.NSDictionary? get userInfo { + final _ret = _objc_msgSend_104(this.pointer, _sel_userInfo); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// setUserInfo: + set userInfo(objc.NSDictionary? value) { + return _objc_msgSend_105( + this.pointer, _sel_setUserInfo_, value?.pointer ?? ffi.nullptr); + } + + /// addUserInfoEntriesFromDictionary: + void addUserInfoEntriesFromDictionary_(objc.NSDictionary otherDictionary) { + _objc_msgSend_513(this.pointer, _sel_addUserInfoEntriesFromDictionary_, + otherDictionary.pointer); + } + + /// requiredUserInfoKeys + objc.NSSet? get requiredUserInfoKeys { + final _ret = _objc_msgSend_514(this.pointer, _sel_requiredUserInfoKeys); + return _ret.address == 0 + ? null + : objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// setRequiredUserInfoKeys: + set requiredUserInfoKeys(objc.NSSet? value) { + return _objc_msgSend_515(this.pointer, _sel_setRequiredUserInfoKeys_, + value?.pointer ?? ffi.nullptr); + } + + /// needsSave + bool get needsSave { + return _objc_msgSend_5(this.pointer, _sel_needsSave); + } + + /// setNeedsSave: + set needsSave(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setNeedsSave_, value); + } + + /// webpageURL + objc.NSURL? get webpageURL { + final _ret = _objc_msgSend_180(this.pointer, _sel_webpageURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// setWebpageURL: + set webpageURL(objc.NSURL? value) { + return _objc_msgSend_516( + this.pointer, _sel_setWebpageURL_, value?.pointer ?? ffi.nullptr); + } + + /// referrerURL + objc.NSURL? get referrerURL { + final _ret = _objc_msgSend_180(this.pointer, _sel_referrerURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// setReferrerURL: + set referrerURL(objc.NSURL? value) { + return _objc_msgSend_516( + this.pointer, _sel_setReferrerURL_, value?.pointer ?? ffi.nullptr); + } + + /// expirationDate + objc.NSDate? get expirationDate { + final _ret = _objc_msgSend_517(this.pointer, _sel_expirationDate); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// setExpirationDate: + set expirationDate(objc.NSDate? value) { + return _objc_msgSend_518( + this.pointer, _sel_setExpirationDate_, value?.pointer ?? ffi.nullptr); + } + + /// keywords + objc.NSSet get keywords { + final _ret = _objc_msgSend_118(this.pointer, _sel_keywords); + return objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// setKeywords: + set keywords(objc.NSSet value) { + return _objc_msgSend_493(this.pointer, _sel_setKeywords_, value.pointer); + } + + /// supportsContinuationStreams + bool get supportsContinuationStreams { + return _objc_msgSend_5(this.pointer, _sel_supportsContinuationStreams); + } + + /// setSupportsContinuationStreams: + set supportsContinuationStreams(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setSupportsContinuationStreams_, value); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// targetContentIdentifier + objc.NSString? get targetContentIdentifier { + final _ret = _objc_msgSend_29(this.pointer, _sel_targetContentIdentifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTargetContentIdentifier: + set targetContentIdentifier(objc.NSString? value) { + return _objc_msgSend_103(this.pointer, _sel_setTargetContentIdentifier_, + value?.pointer ?? ffi.nullptr); + } + + /// becomeCurrent + void becomeCurrent() { + _objc_msgSend_4(this.pointer, _sel_becomeCurrent); + } + + /// resignCurrent + void resignCurrent() { + _objc_msgSend_4(this.pointer, _sel_resignCurrent); + } + + /// invalidate + void invalidate() { + _objc_msgSend_4(this.pointer, _sel_invalidate); + } + + /// getContinuationStreamsWithCompletionHandler: + void getContinuationStreamsWithCompletionHandler_( + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError + completionHandler) { + _objc_msgSend_527( + this.pointer, + _sel_getContinuationStreamsWithCompletionHandler_, + completionHandler.pointer); + } + + /// isEligibleForHandoff + bool get eligibleForHandoff { + return _objc_msgSend_5(this.pointer, _sel_isEligibleForHandoff); + } + + /// setEligibleForHandoff: + set eligibleForHandoff(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setEligibleForHandoff_, value); + } + + /// isEligibleForSearch + bool get eligibleForSearch { + return _objc_msgSend_5(this.pointer, _sel_isEligibleForSearch); + } + + /// setEligibleForSearch: + set eligibleForSearch(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setEligibleForSearch_, value); + } + + /// isEligibleForPublicIndexing + bool get eligibleForPublicIndexing { + return _objc_msgSend_5(this.pointer, _sel_isEligibleForPublicIndexing); + } + + /// setEligibleForPublicIndexing: + set eligibleForPublicIndexing(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setEligibleForPublicIndexing_, value); + } + + /// isEligibleForPrediction + bool get eligibleForPrediction { + return _objc_msgSend_5(this.pointer, _sel_isEligibleForPrediction); + } + + /// setEligibleForPrediction: + set eligibleForPrediction(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setEligibleForPrediction_, value); + } + + /// persistentIdentifier + objc.NSString? get persistentIdentifier { + final _ret = _objc_msgSend_29(this.pointer, _sel_persistentIdentifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setPersistentIdentifier: + set persistentIdentifier(objc.NSString? value) { + return _objc_msgSend_103(this.pointer, _sel_setPersistentIdentifier_, + value?.pointer ?? ffi.nullptr); + } + + /// deleteSavedUserActivitiesWithPersistentIdentifiers:completionHandler: + static void + deleteSavedUserActivitiesWithPersistentIdentifiers_completionHandler_( + objc.NSArray persistentIdentifiers, ObjCBlock_ffiVoid handler) { + _objc_msgSend_528( + _class_NSUserActivity, + _sel_deleteSavedUserActivitiesWithPersistentIdentifiers_completionHandler_, + persistentIdentifiers.pointer, + handler.pointer); + } + + /// deleteAllSavedUserActivitiesWithCompletionHandler: + static void deleteAllSavedUserActivitiesWithCompletionHandler_( + ObjCBlock_ffiVoid handler) { + _objc_msgSend_442( + _class_NSUserActivity, + _sel_deleteAllSavedUserActivitiesWithCompletionHandler_, + handler.pointer); + } + + /// new + static NSUserActivity new1() { + final _ret = _objc_msgSend_18(_class_NSUserActivity, _sel_new); + return NSUserActivity.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSUserActivity allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSUserActivity, _sel_allocWithZone_, zone); + return NSUserActivity.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSUserActivity alloc() { + final _ret = _objc_msgSend_18(_class_NSUserActivity, _sel_alloc); + return NSUserActivity.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSUserActivity = objc.getClass("NSUserActivity"); +late final _sel_initWithActivityType_ = + objc.registerName("initWithActivityType:"); +late final _sel_activityType = objc.registerName("activityType"); +late final _sel_setUserInfo_ = objc.registerName("setUserInfo:"); +late final _sel_addUserInfoEntriesFromDictionary_ = + objc.registerName("addUserInfoEntriesFromDictionary:"); +final _objc_msgSend_513 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_requiredUserInfoKeys = + objc.registerName("requiredUserInfoKeys"); +final _objc_msgSend_514 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setRequiredUserInfoKeys_ = + objc.registerName("setRequiredUserInfoKeys:"); +final _objc_msgSend_515 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_needsSave = objc.registerName("needsSave"); +late final _sel_setNeedsSave_ = objc.registerName("setNeedsSave:"); +late final _sel_webpageURL = objc.registerName("webpageURL"); +late final _sel_setWebpageURL_ = objc.registerName("setWebpageURL:"); +final _objc_msgSend_516 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_referrerURL = objc.registerName("referrerURL"); +late final _sel_setReferrerURL_ = objc.registerName("setReferrerURL:"); +late final _sel_expirationDate = objc.registerName("expirationDate"); +final _objc_msgSend_517 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setExpirationDate_ = objc.registerName("setExpirationDate:"); +final _objc_msgSend_518 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_keywords = objc.registerName("keywords"); +late final _sel_setKeywords_ = objc.registerName("setKeywords:"); +late final _sel_supportsContinuationStreams = + objc.registerName("supportsContinuationStreams"); +late final _sel_setSupportsContinuationStreams_ = + objc.registerName("setSupportsContinuationStreams:"); +late final _sel_targetContentIdentifier = + objc.registerName("targetContentIdentifier"); +late final _sel_setTargetContentIdentifier_ = + objc.registerName("setTargetContentIdentifier:"); +late final _sel_becomeCurrent = objc.registerName("becomeCurrent"); +late final _sel_resignCurrent = objc.registerName("resignCurrent"); +void _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError.fromFunction( + void Function(NSInputStream?, NSOutputStream?, objc.NSError?) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0.address == 0 ? null : NSInputStream.castFromPointer(arg0, retain: true, release: true), + arg1.address == 0 ? null : NSOutputStream.castFromPointer(arg1, retain: true, release: true), + arg2.address == 0 ? null : objc.NSError.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError.listener( + void Function(NSInputStream?, NSOutputStream?, objc.NSError?) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError( + objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= + ffi.NativeCallable, ffi.Pointer, ffi.Pointer, ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + fn( + arg0.address == 0 + ? null + : NSInputStream.castFromPointer(arg0, retain: false, release: true), + arg1.address == 0 ? null : NSOutputStream.castFromPointer(arg1, retain: false, release: true), + arg2.address == 0 ? null : objc.NSError.castFromPointer(arg2, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(NSInputStream? arg0, NSOutputStream? arg1, objc.NSError? arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, + arg0?.pointer ?? ffi.nullptr, + arg1?.pointer ?? ffi.nullptr, + arg2?.pointer ?? ffi.nullptr); +} + +/// NSInputStream +class NSInputStream extends NSStream { + NSInputStream._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSInputStream] that points to the same underlying object as [other]. + NSInputStream.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSInputStream] that wraps the given raw object pointer. + NSInputStream.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSInputStream]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSInputStream); + } + + /// read:maxLength: + int read_maxLength_(ffi.Pointer buffer, int len) { + return _objc_msgSend_519(this.pointer, _sel_read_maxLength_, buffer, len); + } + + /// getBuffer:length: + bool getBuffer_length_(ffi.Pointer> buffer, + ffi.Pointer len) { + return _objc_msgSend_520(this.pointer, _sel_getBuffer_length_, buffer, len); + } + + /// hasBytesAvailable + bool get hasBytesAvailable { + return _objc_msgSend_5(this.pointer, _sel_hasBytesAvailable); + } + + /// initWithData: + NSInputStream initWithData_(objc.NSData data) { + final _ret = + _objc_msgSend_521(this.pointer, _sel_initWithData_, data.pointer); + return NSInputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithURL: + NSInputStream? initWithURL_(objc.NSURL url) { + final _ret = + _objc_msgSend_175(this.pointer, _sel_initWithURL_, url.pointer); + return _ret.address == 0 + ? null + : NSInputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSInputStream init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSInputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSInputStream new1() { + final _ret = _objc_msgSend_18(_class_NSInputStream, _sel_new); + return NSInputStream.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSInputStream allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSInputStream, _sel_allocWithZone_, zone); + return NSInputStream.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSInputStream alloc() { + final _ret = _objc_msgSend_18(_class_NSInputStream, _sel_alloc); + return NSInputStream.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSInputStream = objc.getClass("NSInputStream"); +late final _sel_read_maxLength_ = objc.registerName("read:maxLength:"); +final _objc_msgSend_519 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, int)>(); +late final _sel_getBuffer_length_ = objc.registerName("getBuffer:length:"); +final _objc_msgSend_520 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer)>(); +late final _sel_hasBytesAvailable = objc.registerName("hasBytesAvailable"); +final _objc_msgSend_521 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// NSStream +class NSStream extends objc.NSObject { + NSStream._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSStream] that points to the same underlying object as [other]. + NSStream.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSStream] that wraps the given raw object pointer. + NSStream.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSStream]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSStream); + } + + /// open + void open() { + _objc_msgSend_4(this.pointer, _sel_open); + } + + /// close + void close() { + _objc_msgSend_4(this.pointer, _sel_close); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// propertyForKey: + objc.ObjCObjectBase? propertyForKey_(objc.NSString key) { + final _ret = + _objc_msgSend_57(this.pointer, _sel_propertyForKey_, key.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setProperty:forKey: + bool setProperty_forKey_(objc.ObjCObjectBase? property, objc.NSString key) { + return _objc_msgSend_522(this.pointer, _sel_setProperty_forKey_, + property?.pointer ?? ffi.nullptr, key.pointer); + } + + /// scheduleInRunLoop:forMode: + void scheduleInRunLoop_forMode_(NSRunLoop aRunLoop, objc.NSString mode) { + _objc_msgSend_41(this.pointer, _sel_scheduleInRunLoop_forMode_, + aRunLoop.pointer, mode.pointer); + } + + /// removeFromRunLoop:forMode: + void removeFromRunLoop_forMode_(NSRunLoop aRunLoop, objc.NSString mode) { + _objc_msgSend_41(this.pointer, _sel_removeFromRunLoop_forMode_, + aRunLoop.pointer, mode.pointer); + } + + /// streamStatus + NSStreamStatus get streamStatus { + final _ret = _objc_msgSend_523(this.pointer, _sel_streamStatus); + return NSStreamStatus.fromValue(_ret); + } + + /// streamError + objc.NSError? get streamError { + final _ret = _objc_msgSend_524(this.pointer, _sel_streamError); + return _ret.address == 0 + ? null + : objc.NSError.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSStream init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSStream.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSStream new1() { + final _ret = _objc_msgSend_18(_class_NSStream, _sel_new); + return NSStream.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSStream allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_NSStream, _sel_allocWithZone_, zone); + return NSStream.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSStream alloc() { + final _ret = _objc_msgSend_18(_class_NSStream, _sel_alloc); + return NSStream.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSStream = objc.getClass("NSStream"); +late final _sel_open = objc.registerName("open"); +late final _sel_close = objc.registerName("close"); +late final _sel_propertyForKey_ = objc.registerName("propertyForKey:"); +late final _sel_setProperty_forKey_ = objc.registerName("setProperty:forKey:"); +final _objc_msgSend_522 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +enum NSStreamStatus { + NSStreamStatusNotOpen(0), + NSStreamStatusOpening(1), + NSStreamStatusOpen(2), + NSStreamStatusReading(3), + NSStreamStatusWriting(4), + NSStreamStatusAtEnd(5), + NSStreamStatusClosed(6), + NSStreamStatusError(7); + + final int value; + const NSStreamStatus(this.value); + + static NSStreamStatus fromValue(int value) => switch (value) { + 0 => NSStreamStatusNotOpen, + 1 => NSStreamStatusOpening, + 2 => NSStreamStatusOpen, + 3 => NSStreamStatusReading, + 4 => NSStreamStatusWriting, + 5 => NSStreamStatusAtEnd, + 6 => NSStreamStatusClosed, + 7 => NSStreamStatusError, + _ => throw ArgumentError("Unknown value for NSStreamStatus: $value"), + }; +} + +late final _sel_streamStatus = objc.registerName("streamStatus"); +final _objc_msgSend_523 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_streamError = objc.registerName("streamError"); +final _objc_msgSend_524 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSOutputStream +class NSOutputStream extends NSStream { + NSOutputStream._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSOutputStream] that points to the same underlying object as [other]. + NSOutputStream.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSOutputStream] that wraps the given raw object pointer. + NSOutputStream.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSOutputStream]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSOutputStream); + } + + /// write:maxLength: + int write_maxLength_(ffi.Pointer buffer, int len) { + return _objc_msgSend_519(this.pointer, _sel_write_maxLength_, buffer, len); + } + + /// hasSpaceAvailable + bool get hasSpaceAvailable { + return _objc_msgSend_5(this.pointer, _sel_hasSpaceAvailable); + } + + /// initToMemory + NSOutputStream initToMemory() { + final _ret = _objc_msgSend_18(this.pointer, _sel_initToMemory); + return NSOutputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// initToBuffer:capacity: + NSOutputStream initToBuffer_capacity_( + ffi.Pointer buffer, int capacity) { + final _ret = _objc_msgSend_525( + this.pointer, _sel_initToBuffer_capacity_, buffer, capacity); + return NSOutputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithURL:append: + NSOutputStream? initWithURL_append_(objc.NSURL url, bool shouldAppend) { + final _ret = _objc_msgSend_526( + this.pointer, _sel_initWithURL_append_, url.pointer, shouldAppend); + return _ret.address == 0 + ? null + : NSOutputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSOutputStream init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSOutputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSOutputStream new1() { + final _ret = _objc_msgSend_18(_class_NSOutputStream, _sel_new); + return NSOutputStream.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSOutputStream allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSOutputStream, _sel_allocWithZone_, zone); + return NSOutputStream.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSOutputStream alloc() { + final _ret = _objc_msgSend_18(_class_NSOutputStream, _sel_alloc); + return NSOutputStream.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSOutputStream = objc.getClass("NSOutputStream"); +late final _sel_write_maxLength_ = objc.registerName("write:maxLength:"); +late final _sel_hasSpaceAvailable = objc.registerName("hasSpaceAvailable"); +late final _sel_initToMemory = objc.registerName("initToMemory"); +late final _sel_initToBuffer_capacity_ = + objc.registerName("initToBuffer:capacity:"); +final _objc_msgSend_525 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, int)>(); +late final _sel_initWithURL_append_ = objc.registerName("initWithURL:append:"); +final _objc_msgSend_526 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_getContinuationStreamsWithCompletionHandler_ = + objc.registerName("getContinuationStreamsWithCompletionHandler:"); +final _objc_msgSend_527 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isEligibleForHandoff = + objc.registerName("isEligibleForHandoff"); +late final _sel_setEligibleForHandoff_ = + objc.registerName("setEligibleForHandoff:"); +late final _sel_isEligibleForSearch = objc.registerName("isEligibleForSearch"); +late final _sel_setEligibleForSearch_ = + objc.registerName("setEligibleForSearch:"); +late final _sel_isEligibleForPublicIndexing = + objc.registerName("isEligibleForPublicIndexing"); +late final _sel_setEligibleForPublicIndexing_ = + objc.registerName("setEligibleForPublicIndexing:"); +late final _sel_isEligibleForPrediction = + objc.registerName("isEligibleForPrediction"); +late final _sel_setEligibleForPrediction_ = + objc.registerName("setEligibleForPrediction:"); +late final _sel_setPersistentIdentifier_ = + objc.registerName("setPersistentIdentifier:"); +late final _sel_deleteSavedUserActivitiesWithPersistentIdentifiers_completionHandler_ = + objc.registerName( + "deleteSavedUserActivitiesWithPersistentIdentifiers:completionHandler:"); +final _objc_msgSend_528 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_deleteAllSavedUserActivitiesWithCompletionHandler_ = + objc.registerName("deleteAllSavedUserActivitiesWithCompletionHandler:"); +late final _sel_stateRestorationActivity = + objc.registerName("stateRestorationActivity"); +final _objc_msgSend_529 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setStateRestorationActivity_ = + objc.registerName("setStateRestorationActivity:"); +final _objc_msgSend_530 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// UISceneConnectionOptions +class UISceneConnectionOptions extends objc.NSObject { + UISceneConnectionOptions._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneConnectionOptions] that points to the same underlying object as [other]. + UISceneConnectionOptions.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneConnectionOptions] that wraps the given raw object pointer. + UISceneConnectionOptions.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneConnectionOptions]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UISceneConnectionOptions); + } + + /// new + static UISceneConnectionOptions new1() { + final _ret = _objc_msgSend_18(_class_UISceneConnectionOptions, _sel_new); + return UISceneConnectionOptions.castFromPointer(_ret, + retain: false, release: true); + } + + /// init + UISceneConnectionOptions init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneConnectionOptions.castFromPointer(_ret, + retain: true, release: true); + } + + /// URLContexts + objc.NSSet get URLContexts { + final _ret = _objc_msgSend_118(this.pointer, _sel_URLContexts); + return objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// sourceApplication + objc.NSString? get sourceApplication { + final _ret = _objc_msgSend_29(this.pointer, _sel_sourceApplication); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// handoffUserActivityType + objc.NSString? get handoffUserActivityType { + final _ret = _objc_msgSend_29(this.pointer, _sel_handoffUserActivityType); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// userActivities + objc.NSSet get userActivities { + final _ret = _objc_msgSend_118(this.pointer, _sel_userActivities); + return objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// notificationResponse + UNNotificationResponse? get notificationResponse { + final _ret = _objc_msgSend_532(this.pointer, _sel_notificationResponse); + return _ret.address == 0 + ? null + : UNNotificationResponse.castFromPointer(_ret, + retain: true, release: true); + } + + /// shortcutItem + UIApplicationShortcutItem? get shortcutItem { + final _ret = _objc_msgSend_537(this.pointer, _sel_shortcutItem); + return _ret.address == 0 + ? null + : UIApplicationShortcutItem.castFromPointer(_ret, + retain: true, release: true); + } + + /// cloudKitShareMetadata + CKShareMetadata? get cloudKitShareMetadata { + final _ret = _objc_msgSend_538(this.pointer, _sel_cloudKitShareMetadata); + return _ret.address == 0 + ? null + : CKShareMetadata.castFromPointer(_ret, retain: true, release: true); + } + + /// allocWithZone: + static UISceneConnectionOptions allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UISceneConnectionOptions, _sel_allocWithZone_, zone); + return UISceneConnectionOptions.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UISceneConnectionOptions alloc() { + final _ret = _objc_msgSend_18(_class_UISceneConnectionOptions, _sel_alloc); + return UISceneConnectionOptions.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UISceneConnectionOptions = + objc.getClass("UISceneConnectionOptions"); +late final _sel_URLContexts = objc.registerName("URLContexts"); +late final _sel_sourceApplication = objc.registerName("sourceApplication"); +late final _sel_handoffUserActivityType = + objc.registerName("handoffUserActivityType"); +late final _sel_userActivities = objc.registerName("userActivities"); + +/// UNNotificationResponse +class UNNotificationResponse extends objc.NSObject { + UNNotificationResponse._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UNNotificationResponse] that points to the same underlying object as [other]. + UNNotificationResponse.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UNNotificationResponse] that wraps the given raw object pointer. + UNNotificationResponse.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UNNotificationResponse]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UNNotificationResponse); + } + + /// notification + UNNotification get notification { + final _ret = _objc_msgSend_531(this.pointer, _sel_notification); + return UNNotification.castFromPointer(_ret, retain: true, release: true); + } + + /// actionIdentifier + objc.NSString get actionIdentifier { + final _ret = _objc_msgSend_77(this.pointer, _sel_actionIdentifier); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UNNotificationResponse init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UNNotificationResponse.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UNNotificationResponse new1() { + final _ret = _objc_msgSend_18(_class_UNNotificationResponse, _sel_new); + return UNNotificationResponse.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UNNotificationResponse allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UNNotificationResponse, _sel_allocWithZone_, zone); + return UNNotificationResponse.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UNNotificationResponse alloc() { + final _ret = _objc_msgSend_18(_class_UNNotificationResponse, _sel_alloc); + return UNNotificationResponse.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UNNotificationResponse = + objc.getClass("UNNotificationResponse"); + +/// UNNotification +class UNNotification extends objc.ObjCObjectBase { + UNNotification._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [UNNotification] that points to the same underlying object as [other]. + UNNotification.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UNNotification] that wraps the given raw object pointer. + UNNotification.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UNNotification]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UNNotification); + } +} + +late final _class_UNNotification = objc.getClass("UNNotification"); +late final _sel_notification = objc.registerName("notification"); +final _objc_msgSend_531 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_actionIdentifier = objc.registerName("actionIdentifier"); +late final _sel_notificationResponse = + objc.registerName("notificationResponse"); +final _objc_msgSend_532 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UIApplicationShortcutItem +class UIApplicationShortcutItem extends objc.NSObject { + UIApplicationShortcutItem._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIApplicationShortcutItem] that points to the same underlying object as [other]. + UIApplicationShortcutItem.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIApplicationShortcutItem] that wraps the given raw object pointer. + UIApplicationShortcutItem.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIApplicationShortcutItem]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIApplicationShortcutItem); + } + + /// init + UIApplicationShortcutItem init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIApplicationShortcutItem.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithType:localizedTitle:localizedSubtitle:icon:userInfo: + UIApplicationShortcutItem + initWithType_localizedTitle_localizedSubtitle_icon_userInfo_( + objc.NSString type, + objc.NSString localizedTitle, + objc.NSString? localizedSubtitle, + UIApplicationShortcutIcon? icon, + objc.NSDictionary? userInfo) { + final _ret = _objc_msgSend_534( + this.pointer, + _sel_initWithType_localizedTitle_localizedSubtitle_icon_userInfo_, + type.pointer, + localizedTitle.pointer, + localizedSubtitle?.pointer ?? ffi.nullptr, + icon?.pointer ?? ffi.nullptr, + userInfo?.pointer ?? ffi.nullptr); + return UIApplicationShortcutItem.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithType:localizedTitle: + UIApplicationShortcutItem initWithType_localizedTitle_( + objc.NSString type, objc.NSString localizedTitle) { + final _ret = _objc_msgSend_535( + this.pointer, + _sel_initWithType_localizedTitle_, + type.pointer, + localizedTitle.pointer); + return UIApplicationShortcutItem.castFromPointer(_ret, + retain: true, release: true); + } + + /// type + objc.NSString get type { + final _ret = _objc_msgSend_77(this.pointer, _sel_type); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// localizedTitle + objc.NSString get localizedTitle { + final _ret = _objc_msgSend_77(this.pointer, _sel_localizedTitle); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// localizedSubtitle + objc.NSString? get localizedSubtitle { + final _ret = _objc_msgSend_29(this.pointer, _sel_localizedSubtitle); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// icon + UIApplicationShortcutIcon? get icon { + final _ret = _objc_msgSend_536(this.pointer, _sel_icon); + return _ret.address == 0 + ? null + : UIApplicationShortcutIcon.castFromPointer(_ret, + retain: true, release: true); + } + + /// userInfo + objc.NSDictionary? get userInfo { + final _ret = _objc_msgSend_104(this.pointer, _sel_userInfo); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// targetContentIdentifier + objc.ObjCObjectBase? get targetContentIdentifier { + final _ret = _objc_msgSend_2(this.pointer, _sel_targetContentIdentifier); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// new + static UIApplicationShortcutItem new1() { + final _ret = _objc_msgSend_18(_class_UIApplicationShortcutItem, _sel_new); + return UIApplicationShortcutItem.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIApplicationShortcutItem allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIApplicationShortcutItem, _sel_allocWithZone_, zone); + return UIApplicationShortcutItem.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIApplicationShortcutItem alloc() { + final _ret = _objc_msgSend_18(_class_UIApplicationShortcutItem, _sel_alloc); + return UIApplicationShortcutItem.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIApplicationShortcutItem = + objc.getClass("UIApplicationShortcutItem"); + +/// UIApplicationShortcutIcon +class UIApplicationShortcutIcon extends objc.NSObject { + UIApplicationShortcutIcon._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIApplicationShortcutIcon] that points to the same underlying object as [other]. + UIApplicationShortcutIcon.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIApplicationShortcutIcon] that wraps the given raw object pointer. + UIApplicationShortcutIcon.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIApplicationShortcutIcon]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIApplicationShortcutIcon); + } + + /// iconWithType: + static UIApplicationShortcutIcon iconWithType_( + UIApplicationShortcutIconType type) { + final _ret = _objc_msgSend_533( + _class_UIApplicationShortcutIcon, _sel_iconWithType_, type.value); + return UIApplicationShortcutIcon.castFromPointer(_ret, + retain: true, release: true); + } + + /// iconWithTemplateImageName: + static UIApplicationShortcutIcon iconWithTemplateImageName_( + objc.NSString templateImageName) { + final _ret = _objc_msgSend_95(_class_UIApplicationShortcutIcon, + _sel_iconWithTemplateImageName_, templateImageName.pointer); + return UIApplicationShortcutIcon.castFromPointer(_ret, + retain: true, release: true); + } + + /// iconWithSystemImageName: + static UIApplicationShortcutIcon iconWithSystemImageName_( + objc.NSString systemImageName) { + final _ret = _objc_msgSend_95(_class_UIApplicationShortcutIcon, + _sel_iconWithSystemImageName_, systemImageName.pointer); + return UIApplicationShortcutIcon.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UIApplicationShortcutIcon init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIApplicationShortcutIcon.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIApplicationShortcutIcon new1() { + final _ret = _objc_msgSend_18(_class_UIApplicationShortcutIcon, _sel_new); + return UIApplicationShortcutIcon.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIApplicationShortcutIcon allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIApplicationShortcutIcon, _sel_allocWithZone_, zone); + return UIApplicationShortcutIcon.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIApplicationShortcutIcon alloc() { + final _ret = _objc_msgSend_18(_class_UIApplicationShortcutIcon, _sel_alloc); + return UIApplicationShortcutIcon.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIApplicationShortcutIcon = + objc.getClass("UIApplicationShortcutIcon"); + +enum UIApplicationShortcutIconType { + UIApplicationShortcutIconTypeCompose(0), + UIApplicationShortcutIconTypePlay(1), + UIApplicationShortcutIconTypePause(2), + UIApplicationShortcutIconTypeAdd(3), + UIApplicationShortcutIconTypeLocation(4), + UIApplicationShortcutIconTypeSearch(5), + UIApplicationShortcutIconTypeShare(6), + UIApplicationShortcutIconTypeProhibit(7), + UIApplicationShortcutIconTypeContact(8), + UIApplicationShortcutIconTypeHome(9), + UIApplicationShortcutIconTypeMarkLocation(10), + UIApplicationShortcutIconTypeFavorite(11), + UIApplicationShortcutIconTypeLove(12), + UIApplicationShortcutIconTypeCloud(13), + UIApplicationShortcutIconTypeInvitation(14), + UIApplicationShortcutIconTypeConfirmation(15), + UIApplicationShortcutIconTypeMail(16), + UIApplicationShortcutIconTypeMessage(17), + UIApplicationShortcutIconTypeDate(18), + UIApplicationShortcutIconTypeTime(19), + UIApplicationShortcutIconTypeCapturePhoto(20), + UIApplicationShortcutIconTypeCaptureVideo(21), + UIApplicationShortcutIconTypeTask(22), + UIApplicationShortcutIconTypeTaskCompleted(23), + UIApplicationShortcutIconTypeAlarm(24), + UIApplicationShortcutIconTypeBookmark(25), + UIApplicationShortcutIconTypeShuffle(26), + UIApplicationShortcutIconTypeAudio(27), + UIApplicationShortcutIconTypeUpdate(28); + + final int value; + const UIApplicationShortcutIconType(this.value); + + static UIApplicationShortcutIconType fromValue(int value) => switch (value) { + 0 => UIApplicationShortcutIconTypeCompose, + 1 => UIApplicationShortcutIconTypePlay, + 2 => UIApplicationShortcutIconTypePause, + 3 => UIApplicationShortcutIconTypeAdd, + 4 => UIApplicationShortcutIconTypeLocation, + 5 => UIApplicationShortcutIconTypeSearch, + 6 => UIApplicationShortcutIconTypeShare, + 7 => UIApplicationShortcutIconTypeProhibit, + 8 => UIApplicationShortcutIconTypeContact, + 9 => UIApplicationShortcutIconTypeHome, + 10 => UIApplicationShortcutIconTypeMarkLocation, + 11 => UIApplicationShortcutIconTypeFavorite, + 12 => UIApplicationShortcutIconTypeLove, + 13 => UIApplicationShortcutIconTypeCloud, + 14 => UIApplicationShortcutIconTypeInvitation, + 15 => UIApplicationShortcutIconTypeConfirmation, + 16 => UIApplicationShortcutIconTypeMail, + 17 => UIApplicationShortcutIconTypeMessage, + 18 => UIApplicationShortcutIconTypeDate, + 19 => UIApplicationShortcutIconTypeTime, + 20 => UIApplicationShortcutIconTypeCapturePhoto, + 21 => UIApplicationShortcutIconTypeCaptureVideo, + 22 => UIApplicationShortcutIconTypeTask, + 23 => UIApplicationShortcutIconTypeTaskCompleted, + 24 => UIApplicationShortcutIconTypeAlarm, + 25 => UIApplicationShortcutIconTypeBookmark, + 26 => UIApplicationShortcutIconTypeShuffle, + 27 => UIApplicationShortcutIconTypeAudio, + 28 => UIApplicationShortcutIconTypeUpdate, + _ => throw ArgumentError( + "Unknown value for UIApplicationShortcutIconType: $value"), + }; +} + +late final _sel_iconWithType_ = objc.registerName("iconWithType:"); +final _objc_msgSend_533 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_iconWithTemplateImageName_ = + objc.registerName("iconWithTemplateImageName:"); +late final _sel_iconWithSystemImageName_ = + objc.registerName("iconWithSystemImageName:"); +late final _sel_initWithType_localizedTitle_localizedSubtitle_icon_userInfo_ = + objc.registerName( + "initWithType:localizedTitle:localizedSubtitle:icon:userInfo:"); +final _objc_msgSend_534 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithType_localizedTitle_ = + objc.registerName("initWithType:localizedTitle:"); +final _objc_msgSend_535 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_localizedTitle = objc.registerName("localizedTitle"); +late final _sel_localizedSubtitle = objc.registerName("localizedSubtitle"); +late final _sel_icon = objc.registerName("icon"); +final _objc_msgSend_536 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_shortcutItem = objc.registerName("shortcutItem"); +final _objc_msgSend_537 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// CKShareMetadata +class CKShareMetadata extends objc.ObjCObjectBase { + CKShareMetadata._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [CKShareMetadata] that points to the same underlying object as [other]. + CKShareMetadata.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CKShareMetadata] that wraps the given raw object pointer. + CKShareMetadata.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CKShareMetadata]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_CKShareMetadata); + } +} + +late final _class_CKShareMetadata = objc.getClass("CKShareMetadata"); +late final _sel_cloudKitShareMetadata = + objc.registerName("cloudKitShareMetadata"); +final _objc_msgSend_538 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithSession_connectionOptions_ = + objc.registerName("initWithSession:connectionOptions:"); +final _objc_msgSend_539 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_session = objc.registerName("session"); +final _objc_msgSend_540 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +enum UISceneActivationState { + UISceneActivationStateUnattached(-1), + UISceneActivationStateForegroundActive(0), + UISceneActivationStateForegroundInactive(1), + UISceneActivationStateBackground(2); + + final int value; + const UISceneActivationState(this.value); + + static UISceneActivationState fromValue(int value) => switch (value) { + -1 => UISceneActivationStateUnattached, + 0 => UISceneActivationStateForegroundActive, + 1 => UISceneActivationStateForegroundInactive, + 2 => UISceneActivationStateBackground, + _ => throw ArgumentError( + "Unknown value for UISceneActivationState: $value"), + }; +} + +late final _sel_activationState = objc.registerName("activationState"); +final _objc_msgSend_541 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UISceneOpenExternalURLOptions +class UISceneOpenExternalURLOptions extends objc.NSObject { + UISceneOpenExternalURLOptions._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneOpenExternalURLOptions] that points to the same underlying object as [other]. + UISceneOpenExternalURLOptions.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneOpenExternalURLOptions] that wraps the given raw object pointer. + UISceneOpenExternalURLOptions.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneOpenExternalURLOptions]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UISceneOpenExternalURLOptions); + } + + /// universalLinksOnly + bool get universalLinksOnly { + return _objc_msgSend_5(this.pointer, _sel_universalLinksOnly); + } + + /// setUniversalLinksOnly: + set universalLinksOnly(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setUniversalLinksOnly_, value); + } + + /// eventAttribution + UIEventAttribution? get eventAttribution { + final _ret = _objc_msgSend_544(this.pointer, _sel_eventAttribution); + return _ret.address == 0 + ? null + : UIEventAttribution.castFromPointer(_ret, retain: true, release: true); + } + + /// setEventAttribution: + set eventAttribution(UIEventAttribution? value) { + return _objc_msgSend_545( + this.pointer, _sel_setEventAttribution_, value?.pointer ?? ffi.nullptr); + } + + /// init + UISceneOpenExternalURLOptions init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneOpenExternalURLOptions.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UISceneOpenExternalURLOptions new1() { + final _ret = + _objc_msgSend_18(_class_UISceneOpenExternalURLOptions, _sel_new); + return UISceneOpenExternalURLOptions.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UISceneOpenExternalURLOptions allocWithZone_( + ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UISceneOpenExternalURLOptions, _sel_allocWithZone_, zone); + return UISceneOpenExternalURLOptions.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UISceneOpenExternalURLOptions alloc() { + final _ret = + _objc_msgSend_18(_class_UISceneOpenExternalURLOptions, _sel_alloc); + return UISceneOpenExternalURLOptions.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UISceneOpenExternalURLOptions = + objc.getClass("UISceneOpenExternalURLOptions"); +late final _sel_universalLinksOnly = objc.registerName("universalLinksOnly"); +late final _sel_setUniversalLinksOnly_ = + objc.registerName("setUniversalLinksOnly:"); + +/// UIEventAttribution +class UIEventAttribution extends objc.NSObject { + UIEventAttribution._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIEventAttribution] that points to the same underlying object as [other]. + UIEventAttribution.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIEventAttribution] that wraps the given raw object pointer. + UIEventAttribution.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIEventAttribution]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIEventAttribution); + } + + /// sourceIdentifier + int get sourceIdentifier { + return _objc_msgSend_542(this.pointer, _sel_sourceIdentifier); + } + + /// destinationURL + objc.NSURL get destinationURL { + final _ret = _objc_msgSend_179(this.pointer, _sel_destinationURL); + return objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// reportEndpoint + objc.NSURL? get reportEndpoint { + final _ret = _objc_msgSend_180(this.pointer, _sel_reportEndpoint); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// sourceDescription + objc.NSString get sourceDescription { + final _ret = _objc_msgSend_77(this.pointer, _sel_sourceDescription); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// purchaser + objc.NSString get purchaser { + final _ret = _objc_msgSend_77(this.pointer, _sel_purchaser); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithSourceIdentifier:destinationURL:sourceDescription:purchaser: + UIEventAttribution + initWithSourceIdentifier_destinationURL_sourceDescription_purchaser_( + int sourceIdentifier, + objc.NSURL destinationURL, + objc.NSString sourceDescription, + objc.NSString purchaser) { + final _ret = _objc_msgSend_543( + this.pointer, + _sel_initWithSourceIdentifier_destinationURL_sourceDescription_purchaser_, + sourceIdentifier, + destinationURL.pointer, + sourceDescription.pointer, + purchaser.pointer); + return UIEventAttribution.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UIEventAttribution init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIEventAttribution.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIEventAttribution new1() { + final _ret = _objc_msgSend_18(_class_UIEventAttribution, _sel_new); + return UIEventAttribution.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIEventAttribution allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UIEventAttribution, _sel_allocWithZone_, zone); + return UIEventAttribution.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIEventAttribution alloc() { + final _ret = _objc_msgSend_18(_class_UIEventAttribution, _sel_alloc); + return UIEventAttribution.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIEventAttribution = objc.getClass("UIEventAttribution"); +late final _sel_sourceIdentifier = objc.registerName("sourceIdentifier"); +final _objc_msgSend_542 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Uint8 Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_destinationURL = objc.registerName("destinationURL"); +late final _sel_reportEndpoint = objc.registerName("reportEndpoint"); +late final _sel_sourceDescription = objc.registerName("sourceDescription"); +late final _sel_purchaser = objc.registerName("purchaser"); +late final _sel_initWithSourceIdentifier_destinationURL_sourceDescription_purchaser_ = + objc.registerName( + "initWithSourceIdentifier:destinationURL:sourceDescription:purchaser:"); +final _objc_msgSend_543 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Uint8, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_eventAttribution = objc.registerName("eventAttribution"); +final _objc_msgSend_544 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setEventAttribution_ = + objc.registerName("setEventAttribution:"); +final _objc_msgSend_545 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_546 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// UISceneActivationConditions +class UISceneActivationConditions extends objc.NSObject { + UISceneActivationConditions._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneActivationConditions] that points to the same underlying object as [other]. + UISceneActivationConditions.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneActivationConditions] that wraps the given raw object pointer. + UISceneActivationConditions.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneActivationConditions]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UISceneActivationConditions); + } + + /// init + UISceneActivationConditions init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneActivationConditions.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithCoder: + UISceneActivationConditions? initWithCoder_(objc.NSCoder aDecoder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, aDecoder.pointer); + return _ret.address == 0 + ? null + : UISceneActivationConditions.castFromPointer(_ret, + retain: true, release: true); + } + + /// canActivateForTargetContentIdentifierPredicate + NSPredicate get canActivateForTargetContentIdentifierPredicate { + final _ret = _objc_msgSend_555( + this.pointer, _sel_canActivateForTargetContentIdentifierPredicate); + return NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// setCanActivateForTargetContentIdentifierPredicate: + set canActivateForTargetContentIdentifierPredicate(NSPredicate value) { + return _objc_msgSend_556(this.pointer, + _sel_setCanActivateForTargetContentIdentifierPredicate_, value.pointer); + } + + /// prefersToActivateForTargetContentIdentifierPredicate + NSPredicate get prefersToActivateForTargetContentIdentifierPredicate { + final _ret = _objc_msgSend_555(this.pointer, + _sel_prefersToActivateForTargetContentIdentifierPredicate); + return NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// setPrefersToActivateForTargetContentIdentifierPredicate: + set prefersToActivateForTargetContentIdentifierPredicate(NSPredicate value) { + return _objc_msgSend_556( + this.pointer, + _sel_setPrefersToActivateForTargetContentIdentifierPredicate_, + value.pointer); + } + + /// new + static UISceneActivationConditions new1() { + final _ret = _objc_msgSend_18(_class_UISceneActivationConditions, _sel_new); + return UISceneActivationConditions.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UISceneActivationConditions allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UISceneActivationConditions, _sel_allocWithZone_, zone); + return UISceneActivationConditions.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UISceneActivationConditions alloc() { + final _ret = + _objc_msgSend_18(_class_UISceneActivationConditions, _sel_alloc); + return UISceneActivationConditions.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UISceneActivationConditions = + objc.getClass("UISceneActivationConditions"); + +/// NSPredicate +class NSPredicate extends objc.NSObject { + NSPredicate._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSPredicate] that points to the same underlying object as [other]. + NSPredicate.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSPredicate] that wraps the given raw object pointer. + NSPredicate.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSPredicate]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSPredicate); + } + + /// predicateWithFormat:argumentArray: + static NSPredicate predicateWithFormat_argumentArray_( + objc.NSString predicateFormat, objc.NSArray? arguments) { + final _ret = _objc_msgSend_547( + _class_NSPredicate, + _sel_predicateWithFormat_argumentArray_, + predicateFormat.pointer, + arguments?.pointer ?? ffi.nullptr); + return NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// predicateWithFormat: + static NSPredicate predicateWithFormat_(objc.NSString predicateFormat) { + final _ret = _objc_msgSend_548( + _class_NSPredicate, _sel_predicateWithFormat_, predicateFormat.pointer); + return NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// predicateWithFormat:arguments: + static NSPredicate predicateWithFormat_arguments_( + objc.NSString predicateFormat, ffi.Pointer argList) { + final _ret = _objc_msgSend_549(_class_NSPredicate, + _sel_predicateWithFormat_arguments_, predicateFormat.pointer, argList); + return NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// predicateFromMetadataQueryString: + static NSPredicate? predicateFromMetadataQueryString_( + objc.NSString queryString) { + final _ret = _objc_msgSend_550(_class_NSPredicate, + _sel_predicateFromMetadataQueryString_, queryString.pointer); + return _ret.address == 0 + ? null + : NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// predicateWithValue: + static NSPredicate predicateWithValue_(bool value) { + final _ret = + _objc_msgSend_551(_class_NSPredicate, _sel_predicateWithValue_, value); + return NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// predicateWithBlock: + static NSPredicate predicateWithBlock_( + ObjCBlock_bool_objcObjCObject_NSDictionary block) { + final _ret = _objc_msgSend_552( + _class_NSPredicate, _sel_predicateWithBlock_, block.pointer); + return NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// predicateFormat + objc.NSString get predicateFormat { + final _ret = _objc_msgSend_77(this.pointer, _sel_predicateFormat); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// predicateWithSubstitutionVariables: + NSPredicate predicateWithSubstitutionVariables_(objc.NSDictionary variables) { + final _ret = _objc_msgSend_331(this.pointer, + _sel_predicateWithSubstitutionVariables_, variables.pointer); + return NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// evaluateWithObject: + bool evaluateWithObject_(objc.ObjCObjectBase? object) { + return _objc_msgSend_553( + this.pointer, _sel_evaluateWithObject_, object?.pointer ?? ffi.nullptr); + } + + /// evaluateWithObject:substitutionVariables: + bool evaluateWithObject_substitutionVariables_( + objc.ObjCObjectBase? object, objc.NSDictionary? bindings) { + return _objc_msgSend_554( + this.pointer, + _sel_evaluateWithObject_substitutionVariables_, + object?.pointer ?? ffi.nullptr, + bindings?.pointer ?? ffi.nullptr); + } + + /// allowEvaluation + void allowEvaluation() { + _objc_msgSend_4(this.pointer, _sel_allowEvaluation); + } + + /// init + NSPredicate init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSPredicate.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSPredicate new1() { + final _ret = _objc_msgSend_18(_class_NSPredicate, _sel_new); + return NSPredicate.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSPredicate allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSPredicate, _sel_allocWithZone_, zone); + return NSPredicate.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSPredicate alloc() { + final _ret = _objc_msgSend_18(_class_NSPredicate, _sel_alloc); + return NSPredicate.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSPredicate = objc.getClass("NSPredicate"); +late final _sel_predicateWithFormat_argumentArray_ = + objc.registerName("predicateWithFormat:argumentArray:"); +final _objc_msgSend_547 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_predicateWithFormat_ = + objc.registerName("predicateWithFormat:"); +final _objc_msgSend_548 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_predicateWithFormat_arguments_ = + objc.registerName("predicateWithFormat:arguments:"); +final _objc_msgSend_549 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_predicateFromMetadataQueryString_ = + objc.registerName("predicateFromMetadataQueryString:"); +final _objc_msgSend_550 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_predicateWithValue_ = objc.registerName("predicateWithValue:"); +final _objc_msgSend_551 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Bool)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, bool)>(); +bool _ObjCBlock_bool_objcObjCObject_NSDictionary_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +bool _ObjCBlock_bool_objcObjCObject_NSDictionary_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as bool Function(ffi.Pointer, + ffi.Pointer))(arg0, arg1); + +class ObjCBlock_bool_objcObjCObject_NSDictionary extends objc.ObjCBlockBase { + ObjCBlock_bool_objcObjCObject_NSDictionary._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_objcObjCObject_NSDictionary castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_objcObjCObject_NSDictionary._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_objcObjCObject_NSDictionary.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_objcObjCObject_NSDictionary_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_objcObjCObject_NSDictionary.fromFunction( + bool Function(objc.ObjCObjectBase?, objc.NSDictionary?) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_objcObjCObject_NSDictionary_closureTrampoline, false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0.address == 0 ? null : objc.ObjCObjectBase(arg0, retain: true, release: true), + arg1.address == 0 ? null : objc.NSDictionary.castFromPointer(arg1, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(objc.ObjCObjectBase? arg0, objc.NSDictionary? arg1) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0?.pointer ?? ffi.nullptr, arg1?.pointer ?? ffi.nullptr); +} + +late final _sel_predicateWithBlock_ = objc.registerName("predicateWithBlock:"); +final _objc_msgSend_552 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_predicateFormat = objc.registerName("predicateFormat"); +late final _sel_predicateWithSubstitutionVariables_ = + objc.registerName("predicateWithSubstitutionVariables:"); +late final _sel_evaluateWithObject_ = objc.registerName("evaluateWithObject:"); +final _objc_msgSend_553 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_evaluateWithObject_substitutionVariables_ = + objc.registerName("evaluateWithObject:substitutionVariables:"); +final _objc_msgSend_554 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_allowEvaluation = objc.registerName("allowEvaluation"); +late final _sel_canActivateForTargetContentIdentifierPredicate = + objc.registerName("canActivateForTargetContentIdentifierPredicate"); +final _objc_msgSend_555 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setCanActivateForTargetContentIdentifierPredicate_ = + objc.registerName("setCanActivateForTargetContentIdentifierPredicate:"); +final _objc_msgSend_556 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_prefersToActivateForTargetContentIdentifierPredicate = + objc.registerName("prefersToActivateForTargetContentIdentifierPredicate"); +late final _sel_setPrefersToActivateForTargetContentIdentifierPredicate_ = objc + .registerName("setPrefersToActivateForTargetContentIdentifierPredicate:"); +late final _sel_activationConditions = + objc.registerName("activationConditions"); +final _objc_msgSend_557 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setActivationConditions_ = + objc.registerName("setActivationConditions:"); +final _objc_msgSend_558 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithWindowScene_ = + objc.registerName("initWithWindowScene:"); +final _objc_msgSend_559 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_windowScene = objc.registerName("windowScene"); +final _objc_msgSend_560 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setWindowScene_ = objc.registerName("setWindowScene:"); +final _objc_msgSend_561 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_canResizeToFitContent = + objc.registerName("canResizeToFitContent"); +late final _sel_setCanResizeToFitContent_ = + objc.registerName("setCanResizeToFitContent:"); +late final _sel_setScreen_ = objc.registerName("setScreen:"); +final _objc_msgSend_562 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_windowLevel = objc.registerName("windowLevel"); +late final _sel_setWindowLevel_ = objc.registerName("setWindowLevel:"); +late final _sel_isKeyWindow = objc.registerName("isKeyWindow"); +late final _sel_canBecomeKeyWindow = objc.registerName("canBecomeKeyWindow"); +late final _sel_becomeKeyWindow = objc.registerName("becomeKeyWindow"); +late final _sel_resignKeyWindow = objc.registerName("resignKeyWindow"); +late final _sel_makeKeyWindow = objc.registerName("makeKeyWindow"); +late final _sel_makeKeyAndVisible = objc.registerName("makeKeyAndVisible"); +late final _sel_rootViewController = objc.registerName("rootViewController"); +late final _sel_setRootViewController_ = + objc.registerName("setRootViewController:"); +final _objc_msgSend_563 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_sendEvent_ = objc.registerName("sendEvent:"); +final _objc_msgSend_564 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_convertPoint_toWindow_ = + objc.registerName("convertPoint:toWindow:"); +final _objc_msgSend_565 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>>() + .asFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>(); +final _objc_msgSend_565Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>(); +late final _sel_convertPoint_fromWindow_ = + objc.registerName("convertPoint:fromWindow:"); +late final _sel_convertRect_toWindow_ = + objc.registerName("convertRect:toWindow:"); +final _objc_msgSend_566 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +final _objc_msgSend_566Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +late final _sel_convertRect_fromWindow_ = + objc.registerName("convertRect:fromWindow:"); +late final _sel_touchesForWindow_ = objc.registerName("touchesForWindow:"); +final _objc_msgSend_567 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_touchesForView_ = objc.registerName("touchesForView:"); +final _objc_msgSend_568 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_touchesForGestureRecognizer_ = + objc.registerName("touchesForGestureRecognizer:"); +final _objc_msgSend_569 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_coalescedTouchesForTouch_ = + objc.registerName("coalescedTouchesForTouch:"); +final _objc_msgSend_570 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_predictedTouchesForTouch_ = + objc.registerName("predictedTouchesForTouch:"); +late final _sel_sendAction_to_from_forEvent_ = + objc.registerName("sendAction:to:from:forEvent:"); +final _objc_msgSend_571 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_isNetworkActivityIndicatorVisible = + objc.registerName("isNetworkActivityIndicatorVisible"); +late final _sel_setNetworkActivityIndicatorVisible_ = + objc.registerName("setNetworkActivityIndicatorVisible:"); +late final _sel_statusBarStyle = objc.registerName("statusBarStyle"); +late final _sel_isStatusBarHidden = objc.registerName("isStatusBarHidden"); +late final _sel_statusBarOrientation = + objc.registerName("statusBarOrientation"); + +enum UIInterfaceOrientationMask { + UIInterfaceOrientationMaskPortrait(2), + UIInterfaceOrientationMaskLandscapeLeft(16), + UIInterfaceOrientationMaskLandscapeRight(8), + UIInterfaceOrientationMaskPortraitUpsideDown(4), + UIInterfaceOrientationMaskLandscape(24), + UIInterfaceOrientationMaskAll(30), + UIInterfaceOrientationMaskAllButUpsideDown(26); + + final int value; + const UIInterfaceOrientationMask(this.value); + + static UIInterfaceOrientationMask fromValue(int value) => switch (value) { + 2 => UIInterfaceOrientationMaskPortrait, + 16 => UIInterfaceOrientationMaskLandscapeLeft, + 8 => UIInterfaceOrientationMaskLandscapeRight, + 4 => UIInterfaceOrientationMaskPortraitUpsideDown, + 24 => UIInterfaceOrientationMaskLandscape, + 30 => UIInterfaceOrientationMaskAll, + 26 => UIInterfaceOrientationMaskAllButUpsideDown, + _ => throw ArgumentError( + "Unknown value for UIInterfaceOrientationMask: $value"), + }; +} + +late final _sel_supportedInterfaceOrientationsForWindow_ = + objc.registerName("supportedInterfaceOrientationsForWindow:"); +final _objc_msgSend_572 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_statusBarOrientationAnimationDuration = + objc.registerName("statusBarOrientationAnimationDuration"); +late final _sel_statusBarFrame = objc.registerName("statusBarFrame"); +late final _sel_applicationIconBadgeNumber = + objc.registerName("applicationIconBadgeNumber"); +late final _sel_setApplicationIconBadgeNumber_ = + objc.registerName("setApplicationIconBadgeNumber:"); +late final _sel_applicationSupportsShakeToEdit = + objc.registerName("applicationSupportsShakeToEdit"); +late final _sel_setApplicationSupportsShakeToEdit_ = + objc.registerName("setApplicationSupportsShakeToEdit:"); + +enum UIApplicationState { + UIApplicationStateActive(0), + UIApplicationStateInactive(1), + UIApplicationStateBackground(2); + + final int value; + const UIApplicationState(this.value); + + static UIApplicationState fromValue(int value) => switch (value) { + 0 => UIApplicationStateActive, + 1 => UIApplicationStateInactive, + 2 => UIApplicationStateBackground, + _ => + throw ArgumentError("Unknown value for UIApplicationState: $value"), + }; +} + +late final _sel_applicationState = objc.registerName("applicationState"); +final _objc_msgSend_573 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_backgroundTimeRemaining = + objc.registerName("backgroundTimeRemaining"); +late final _sel_beginBackgroundTaskWithExpirationHandler_ = + objc.registerName("beginBackgroundTaskWithExpirationHandler:"); +final _objc_msgSend_574 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_beginBackgroundTaskWithName_expirationHandler_ = + objc.registerName("beginBackgroundTaskWithName:expirationHandler:"); +final _objc_msgSend_575 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_endBackgroundTask_ = objc.registerName("endBackgroundTask:"); +final _objc_msgSend_576 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_setMinimumBackgroundFetchInterval_ = + objc.registerName("setMinimumBackgroundFetchInterval:"); +final _objc_msgSend_577 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, double)>(); + +enum UIBackgroundRefreshStatus { + UIBackgroundRefreshStatusRestricted(0), + UIBackgroundRefreshStatusDenied(1), + UIBackgroundRefreshStatusAvailable(2); + + final int value; + const UIBackgroundRefreshStatus(this.value); + + static UIBackgroundRefreshStatus fromValue(int value) => switch (value) { + 0 => UIBackgroundRefreshStatusRestricted, + 1 => UIBackgroundRefreshStatusDenied, + 2 => UIBackgroundRefreshStatusAvailable, + _ => throw ArgumentError( + "Unknown value for UIBackgroundRefreshStatus: $value"), + }; +} + +late final _sel_backgroundRefreshStatus = + objc.registerName("backgroundRefreshStatus"); +final _objc_msgSend_578 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isProtectedDataAvailable = + objc.registerName("isProtectedDataAvailable"); +late final _sel_userInterfaceLayoutDirection = + objc.registerName("userInterfaceLayoutDirection"); +late final _sel_connectedScenes = objc.registerName("connectedScenes"); +late final _sel_openSessions = objc.registerName("openSessions"); +late final _sel_supportsMultipleScenes = + objc.registerName("supportsMultipleScenes"); + +/// UISceneSessionActivationRequest +class UISceneSessionActivationRequest extends objc.NSObject { + UISceneSessionActivationRequest._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneSessionActivationRequest] that points to the same underlying object as [other]. + UISceneSessionActivationRequest.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneSessionActivationRequest] that wraps the given raw object pointer. + UISceneSessionActivationRequest.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneSessionActivationRequest]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, + _class_UISceneSessionActivationRequest); + } + + /// role + objc.NSString get role { + final _ret = _objc_msgSend_77(this.pointer, _sel_role); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// session + UISceneSession? get session { + final _ret = _objc_msgSend_579(this.pointer, _sel_session); + return _ret.address == 0 + ? null + : UISceneSession.castFromPointer(_ret, retain: true, release: true); + } + + /// userActivity + NSUserActivity? get userActivity { + final _ret = _objc_msgSend_529(this.pointer, _sel_userActivity); + return _ret.address == 0 + ? null + : NSUserActivity.castFromPointer(_ret, retain: true, release: true); + } + + /// setUserActivity: + set userActivity(NSUserActivity? value) { + return _objc_msgSend_530( + this.pointer, _sel_setUserActivity_, value?.pointer ?? ffi.nullptr); + } + + /// options + UISceneActivationRequestOptions? get options { + final _ret = _objc_msgSend_583(this.pointer, _sel_options); + return _ret.address == 0 + ? null + : UISceneActivationRequestOptions.castFromPointer(_ret, + retain: true, release: true); + } + + /// setOptions: + set options(UISceneActivationRequestOptions? value) { + return _objc_msgSend_584( + this.pointer, _sel_setOptions_, value?.pointer ?? ffi.nullptr); + } + + /// request + static UISceneSessionActivationRequest request() { + final _ret = + _objc_msgSend_18(_class_UISceneSessionActivationRequest, _sel_request); + return UISceneSessionActivationRequest.castFromPointer(_ret, + retain: true, release: true); + } + + /// requestWithRole: + static UISceneSessionActivationRequest requestWithRole_(objc.NSString role) { + final _ret = _objc_msgSend_95(_class_UISceneSessionActivationRequest, + _sel_requestWithRole_, role.pointer); + return UISceneSessionActivationRequest.castFromPointer(_ret, + retain: true, release: true); + } + + /// requestWithSession: + static UISceneSessionActivationRequest requestWithSession_( + UISceneSession session) { + final _ret = _objc_msgSend_585(_class_UISceneSessionActivationRequest, + _sel_requestWithSession_, session.pointer); + return UISceneSessionActivationRequest.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + UISceneSessionActivationRequest init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneSessionActivationRequest.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UISceneSessionActivationRequest new1() { + final _ret = + _objc_msgSend_18(_class_UISceneSessionActivationRequest, _sel_new); + return UISceneSessionActivationRequest.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UISceneSessionActivationRequest allocWithZone_( + ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UISceneSessionActivationRequest, _sel_allocWithZone_, zone); + return UISceneSessionActivationRequest.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UISceneSessionActivationRequest alloc() { + final _ret = + _objc_msgSend_18(_class_UISceneSessionActivationRequest, _sel_alloc); + return UISceneSessionActivationRequest.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UISceneSessionActivationRequest = + objc.getClass("UISceneSessionActivationRequest"); +final _objc_msgSend_579 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_userActivity = objc.registerName("userActivity"); +late final _sel_setUserActivity_ = objc.registerName("setUserActivity:"); + +/// UISceneActivationRequestOptions +class UISceneActivationRequestOptions extends objc.NSObject { + UISceneActivationRequestOptions._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneActivationRequestOptions] that points to the same underlying object as [other]. + UISceneActivationRequestOptions.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneActivationRequestOptions] that wraps the given raw object pointer. + UISceneActivationRequestOptions.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneActivationRequestOptions]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, + _class_UISceneActivationRequestOptions); + } + + /// requestingScene + UIScene? get requestingScene { + final _ret = _objc_msgSend_383(this.pointer, _sel_requestingScene); + return _ret.address == 0 + ? null + : UIScene.castFromPointer(_ret, retain: true, release: true); + } + + /// setRequestingScene: + set requestingScene(UIScene? value) { + return _objc_msgSend_580( + this.pointer, _sel_setRequestingScene_, value?.pointer ?? ffi.nullptr); + } + + /// collectionJoinBehavior + UISceneCollectionJoinBehavior get collectionJoinBehavior { + final _ret = _objc_msgSend_581(this.pointer, _sel_collectionJoinBehavior); + return UISceneCollectionJoinBehavior.fromValue(_ret); + } + + /// setCollectionJoinBehavior: + set collectionJoinBehavior(UISceneCollectionJoinBehavior value) { + return _objc_msgSend_582( + this.pointer, _sel_setCollectionJoinBehavior_, value.value); + } + + /// init + UISceneActivationRequestOptions init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneActivationRequestOptions.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UISceneActivationRequestOptions new1() { + final _ret = + _objc_msgSend_18(_class_UISceneActivationRequestOptions, _sel_new); + return UISceneActivationRequestOptions.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UISceneActivationRequestOptions allocWithZone_( + ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UISceneActivationRequestOptions, _sel_allocWithZone_, zone); + return UISceneActivationRequestOptions.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UISceneActivationRequestOptions alloc() { + final _ret = + _objc_msgSend_18(_class_UISceneActivationRequestOptions, _sel_alloc); + return UISceneActivationRequestOptions.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UISceneActivationRequestOptions = + objc.getClass("UISceneActivationRequestOptions"); +late final _sel_requestingScene = objc.registerName("requestingScene"); +late final _sel_setRequestingScene_ = objc.registerName("setRequestingScene:"); +final _objc_msgSend_580 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +enum UISceneCollectionJoinBehavior { + UISceneCollectionJoinBehaviorAutomatic(0), + UISceneCollectionJoinBehaviorPreferred(1), + UISceneCollectionJoinBehaviorDisallowed(2), + UISceneCollectionJoinBehaviorPreferredWithoutActivating(3); + + final int value; + const UISceneCollectionJoinBehavior(this.value); + + static UISceneCollectionJoinBehavior fromValue(int value) => switch (value) { + 0 => UISceneCollectionJoinBehaviorAutomatic, + 1 => UISceneCollectionJoinBehaviorPreferred, + 2 => UISceneCollectionJoinBehaviorDisallowed, + 3 => UISceneCollectionJoinBehaviorPreferredWithoutActivating, + _ => throw ArgumentError( + "Unknown value for UISceneCollectionJoinBehavior: $value"), + }; +} + +late final _sel_collectionJoinBehavior = + objc.registerName("collectionJoinBehavior"); +final _objc_msgSend_581 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setCollectionJoinBehavior_ = + objc.registerName("setCollectionJoinBehavior:"); +final _objc_msgSend_582 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +final _objc_msgSend_583 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setOptions_ = objc.registerName("setOptions:"); +final _objc_msgSend_584 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_request = objc.registerName("request"); +late final _sel_requestWithRole_ = objc.registerName("requestWithRole:"); +late final _sel_requestWithSession_ = objc.registerName("requestWithSession:"); +final _objc_msgSend_585 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_activateSceneSessionForRequest_errorHandler_ = + objc.registerName("activateSceneSessionForRequest:errorHandler:"); +final _objc_msgSend_586 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_requestSceneSessionActivation_userActivity_options_errorHandler_ = + objc.registerName( + "requestSceneSessionActivation:userActivity:options:errorHandler:"); +final _objc_msgSend_587 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// UISceneDestructionRequestOptions +class UISceneDestructionRequestOptions extends objc.NSObject { + UISceneDestructionRequestOptions._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UISceneDestructionRequestOptions] that points to the same underlying object as [other]. + UISceneDestructionRequestOptions.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UISceneDestructionRequestOptions] that wraps the given raw object pointer. + UISceneDestructionRequestOptions.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UISceneDestructionRequestOptions]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, + _class_UISceneDestructionRequestOptions); + } + + /// init + UISceneDestructionRequestOptions init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UISceneDestructionRequestOptions.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UISceneDestructionRequestOptions new1() { + final _ret = + _objc_msgSend_18(_class_UISceneDestructionRequestOptions, _sel_new); + return UISceneDestructionRequestOptions.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UISceneDestructionRequestOptions allocWithZone_( + ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UISceneDestructionRequestOptions, _sel_allocWithZone_, zone); + return UISceneDestructionRequestOptions.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UISceneDestructionRequestOptions alloc() { + final _ret = + _objc_msgSend_18(_class_UISceneDestructionRequestOptions, _sel_alloc); + return UISceneDestructionRequestOptions.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UISceneDestructionRequestOptions = + objc.getClass("UISceneDestructionRequestOptions"); +late final _sel_requestSceneSessionDestruction_options_errorHandler_ = + objc.registerName("requestSceneSessionDestruction:options:errorHandler:"); +final _objc_msgSend_588 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_requestSceneSessionRefresh_ = + objc.registerName("requestSceneSessionRefresh:"); +final _objc_msgSend_589 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_registerForRemoteNotifications = + objc.registerName("registerForRemoteNotifications"); +late final _sel_unregisterForRemoteNotifications = + objc.registerName("unregisterForRemoteNotifications"); +late final _sel_isRegisteredForRemoteNotifications = + objc.registerName("isRegisteredForRemoteNotifications"); + +enum UIRemoteNotificationType { + UIRemoteNotificationTypeNone(0), + UIRemoteNotificationTypeBadge(1), + UIRemoteNotificationTypeSound(2), + UIRemoteNotificationTypeAlert(4), + UIRemoteNotificationTypeNewsstandContentAvailability(8); + + final int value; + const UIRemoteNotificationType(this.value); + + static UIRemoteNotificationType fromValue(int value) => switch (value) { + 0 => UIRemoteNotificationTypeNone, + 1 => UIRemoteNotificationTypeBadge, + 2 => UIRemoteNotificationTypeSound, + 4 => UIRemoteNotificationTypeAlert, + 8 => UIRemoteNotificationTypeNewsstandContentAvailability, + _ => throw ArgumentError( + "Unknown value for UIRemoteNotificationType: $value"), + }; +} + +late final _sel_registerForRemoteNotificationTypes_ = + objc.registerName("registerForRemoteNotificationTypes:"); +final _objc_msgSend_590 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_enabledRemoteNotificationTypes = + objc.registerName("enabledRemoteNotificationTypes"); +final _objc_msgSend_591 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +/// UILocalNotification +class UILocalNotification extends objc.NSObject { + UILocalNotification._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UILocalNotification] that points to the same underlying object as [other]. + UILocalNotification.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UILocalNotification] that wraps the given raw object pointer. + UILocalNotification.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UILocalNotification]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UILocalNotification); + } + + /// init + UILocalNotification init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UILocalNotification.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithCoder: + UILocalNotification? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_55(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : UILocalNotification.castFromPointer(_ret, + retain: true, release: true); + } + + /// fireDate + objc.NSDate? get fireDate { + final _ret = _objc_msgSend_517(this.pointer, _sel_fireDate); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// setFireDate: + set fireDate(objc.NSDate? value) { + return _objc_msgSend_518( + this.pointer, _sel_setFireDate_, value?.pointer ?? ffi.nullptr); + } + + /// timeZone + NSTimeZone? get timeZone { + final _ret = _objc_msgSend_598(this.pointer, _sel_timeZone); + return _ret.address == 0 + ? null + : NSTimeZone.castFromPointer(_ret, retain: true, release: true); + } + + /// setTimeZone: + set timeZone(NSTimeZone? value) { + return _objc_msgSend_599( + this.pointer, _sel_setTimeZone_, value?.pointer ?? ffi.nullptr); + } + + /// repeatInterval + NSCalendarUnit get repeatInterval { + final _ret = _objc_msgSend_600(this.pointer, _sel_repeatInterval); + return NSCalendarUnit.fromValue(_ret); + } + + /// setRepeatInterval: + set repeatInterval(NSCalendarUnit value) { + return _objc_msgSend_601( + this.pointer, _sel_setRepeatInterval_, value.value); + } + + /// repeatCalendar + NSCalendar? get repeatCalendar { + final _ret = _objc_msgSend_611(this.pointer, _sel_repeatCalendar); + return _ret.address == 0 + ? null + : NSCalendar.castFromPointer(_ret, retain: true, release: true); + } + + /// setRepeatCalendar: + set repeatCalendar(NSCalendar? value) { + return _objc_msgSend_612( + this.pointer, _sel_setRepeatCalendar_, value?.pointer ?? ffi.nullptr); + } + + /// region + CLRegion? get region { + final _ret = _objc_msgSend_639(this.pointer, _sel_region); + return _ret.address == 0 + ? null + : CLRegion.castFromPointer(_ret, retain: true, release: true); + } + + /// setRegion: + set region(CLRegion? value) { + return _objc_msgSend_640( + this.pointer, _sel_setRegion_, value?.pointer ?? ffi.nullptr); + } + + /// regionTriggersOnce + bool get regionTriggersOnce { + return _objc_msgSend_5(this.pointer, _sel_regionTriggersOnce); + } + + /// setRegionTriggersOnce: + set regionTriggersOnce(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setRegionTriggersOnce_, value); + } + + /// alertBody + objc.NSString? get alertBody { + final _ret = _objc_msgSend_29(this.pointer, _sel_alertBody); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setAlertBody: + set alertBody(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setAlertBody_, value?.pointer ?? ffi.nullptr); + } + + /// hasAction + bool get hasAction { + return _objc_msgSend_5(this.pointer, _sel_hasAction); + } + + /// setHasAction: + set hasAction(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setHasAction_, value); + } + + /// alertAction + objc.NSString? get alertAction { + final _ret = _objc_msgSend_29(this.pointer, _sel_alertAction); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setAlertAction: + set alertAction(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setAlertAction_, value?.pointer ?? ffi.nullptr); + } + + /// alertLaunchImage + objc.NSString? get alertLaunchImage { + final _ret = _objc_msgSend_29(this.pointer, _sel_alertLaunchImage); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setAlertLaunchImage: + set alertLaunchImage(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setAlertLaunchImage_, value?.pointer ?? ffi.nullptr); + } + + /// alertTitle + objc.NSString? get alertTitle { + final _ret = _objc_msgSend_29(this.pointer, _sel_alertTitle); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setAlertTitle: + set alertTitle(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setAlertTitle_, value?.pointer ?? ffi.nullptr); + } + + /// soundName + objc.NSString? get soundName { + final _ret = _objc_msgSend_29(this.pointer, _sel_soundName); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setSoundName: + set soundName(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setSoundName_, value?.pointer ?? ffi.nullptr); + } + + /// applicationIconBadgeNumber + int get applicationIconBadgeNumber { + return _objc_msgSend_48(this.pointer, _sel_applicationIconBadgeNumber); + } + + /// setApplicationIconBadgeNumber: + set applicationIconBadgeNumber(int value) { + return _objc_msgSend_49( + this.pointer, _sel_setApplicationIconBadgeNumber_, value); + } + + /// userInfo + objc.NSDictionary? get userInfo { + final _ret = _objc_msgSend_104(this.pointer, _sel_userInfo); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// setUserInfo: + set userInfo(objc.NSDictionary? value) { + return _objc_msgSend_105( + this.pointer, _sel_setUserInfo_, value?.pointer ?? ffi.nullptr); + } + + /// category + objc.NSString? get category { + final _ret = _objc_msgSend_29(this.pointer, _sel_category); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setCategory: + set category(objc.NSString? value) { + return _objc_msgSend_103( + this.pointer, _sel_setCategory_, value?.pointer ?? ffi.nullptr); + } + + /// new + static UILocalNotification new1() { + final _ret = _objc_msgSend_18(_class_UILocalNotification, _sel_new); + return UILocalNotification.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UILocalNotification allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_UILocalNotification, _sel_allocWithZone_, zone); + return UILocalNotification.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UILocalNotification alloc() { + final _ret = _objc_msgSend_18(_class_UILocalNotification, _sel_alloc); + return UILocalNotification.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UILocalNotification = objc.getClass("UILocalNotification"); + +/// NSTimeZone +class NSTimeZone extends objc.NSObject { + NSTimeZone._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSTimeZone] that points to the same underlying object as [other]. + NSTimeZone.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSTimeZone] that wraps the given raw object pointer. + NSTimeZone.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSTimeZone]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSTimeZone); + } + + /// name + objc.NSString get name { + final _ret = _objc_msgSend_77(this.pointer, _sel_name); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// data + objc.NSData get data { + final _ret = _objc_msgSend_592(this.pointer, _sel_data); + return objc.NSData.castFromPointer(_ret, retain: true, release: true); + } + + /// secondsFromGMTForDate: + int secondsFromGMTForDate_(objc.NSDate aDate) { + return _objc_msgSend_593( + this.pointer, _sel_secondsFromGMTForDate_, aDate.pointer); + } + + /// abbreviationForDate: + objc.NSString? abbreviationForDate_(objc.NSDate aDate) { + final _ret = _objc_msgSend_594( + this.pointer, _sel_abbreviationForDate_, aDate.pointer); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// isDaylightSavingTimeForDate: + bool isDaylightSavingTimeForDate_(objc.NSDate aDate) { + return _objc_msgSend_595( + this.pointer, _sel_isDaylightSavingTimeForDate_, aDate.pointer); + } + + /// daylightSavingTimeOffsetForDate: + double daylightSavingTimeOffsetForDate_(objc.NSDate aDate) { + return objc.useMsgSendVariants + ? _objc_msgSend_596Fpret( + this.pointer, _sel_daylightSavingTimeOffsetForDate_, aDate.pointer) + : _objc_msgSend_596( + this.pointer, _sel_daylightSavingTimeOffsetForDate_, aDate.pointer); + } + + /// nextDaylightSavingTimeTransitionAfterDate: + objc.NSDate? nextDaylightSavingTimeTransitionAfterDate_(objc.NSDate aDate) { + final _ret = _objc_msgSend_597(this.pointer, + _sel_nextDaylightSavingTimeTransitionAfterDate_, aDate.pointer); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSTimeZone init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSTimeZone.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSTimeZone new1() { + final _ret = _objc_msgSend_18(_class_NSTimeZone, _sel_new); + return NSTimeZone.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSTimeZone allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_NSTimeZone, _sel_allocWithZone_, zone); + return NSTimeZone.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSTimeZone alloc() { + final _ret = _objc_msgSend_18(_class_NSTimeZone, _sel_alloc); + return NSTimeZone.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSTimeZone = objc.getClass("NSTimeZone"); +late final _sel_data = objc.registerName("data"); +final _objc_msgSend_592 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_secondsFromGMTForDate_ = + objc.registerName("secondsFromGMTForDate:"); +final _objc_msgSend_593 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_abbreviationForDate_ = + objc.registerName("abbreviationForDate:"); +final _objc_msgSend_594 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isDaylightSavingTimeForDate_ = + objc.registerName("isDaylightSavingTimeForDate:"); +final _objc_msgSend_595 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_daylightSavingTimeOffsetForDate_ = + objc.registerName("daylightSavingTimeOffsetForDate:"); +final _objc_msgSend_596 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_596Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_nextDaylightSavingTimeTransitionAfterDate_ = + objc.registerName("nextDaylightSavingTimeTransitionAfterDate:"); +final _objc_msgSend_597 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_timeZone = objc.registerName("timeZone"); +final _objc_msgSend_598 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setTimeZone_ = objc.registerName("setTimeZone:"); +final _objc_msgSend_599 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +enum NSCalendarUnit { + NSCalendarUnitEra(2), + NSCalendarUnitYear(4), + NSCalendarUnitMonth(8), + NSCalendarUnitDay(16), + NSCalendarUnitHour(32), + NSCalendarUnitMinute(64), + NSCalendarUnitSecond(128), + NSCalendarUnitWeekday(512), + NSCalendarUnitWeekdayOrdinal(1024), + NSCalendarUnitQuarter(2048), + NSCalendarUnitWeekOfMonth(4096), + NSCalendarUnitWeekOfYear(8192), + NSCalendarUnitYearForWeekOfYear(16384), + NSCalendarUnitNanosecond(32768), + NSCalendarUnitCalendar(1048576), + NSCalendarUnitTimeZone(2097152), + NSWeekCalendarUnit(256); + + static const NSEraCalendarUnit = NSCalendarUnitEra; + static const NSYearCalendarUnit = NSCalendarUnitYear; + static const NSMonthCalendarUnit = NSCalendarUnitMonth; + static const NSDayCalendarUnit = NSCalendarUnitDay; + static const NSHourCalendarUnit = NSCalendarUnitHour; + static const NSMinuteCalendarUnit = NSCalendarUnitMinute; + static const NSSecondCalendarUnit = NSCalendarUnitSecond; + static const NSWeekdayCalendarUnit = NSCalendarUnitWeekday; + static const NSWeekdayOrdinalCalendarUnit = NSCalendarUnitWeekdayOrdinal; + static const NSQuarterCalendarUnit = NSCalendarUnitQuarter; + static const NSWeekOfMonthCalendarUnit = NSCalendarUnitWeekOfMonth; + static const NSWeekOfYearCalendarUnit = NSCalendarUnitWeekOfYear; + static const NSYearForWeekOfYearCalendarUnit = + NSCalendarUnitYearForWeekOfYear; + static const NSCalendarCalendarUnit = NSCalendarUnitCalendar; + static const NSTimeZoneCalendarUnit = NSCalendarUnitTimeZone; + + final int value; + const NSCalendarUnit(this.value); + + static NSCalendarUnit fromValue(int value) => switch (value) { + 2 => NSCalendarUnitEra, + 4 => NSCalendarUnitYear, + 8 => NSCalendarUnitMonth, + 16 => NSCalendarUnitDay, + 32 => NSCalendarUnitHour, + 64 => NSCalendarUnitMinute, + 128 => NSCalendarUnitSecond, + 512 => NSCalendarUnitWeekday, + 1024 => NSCalendarUnitWeekdayOrdinal, + 2048 => NSCalendarUnitQuarter, + 4096 => NSCalendarUnitWeekOfMonth, + 8192 => NSCalendarUnitWeekOfYear, + 16384 => NSCalendarUnitYearForWeekOfYear, + 32768 => NSCalendarUnitNanosecond, + 1048576 => NSCalendarUnitCalendar, + 2097152 => NSCalendarUnitTimeZone, + 256 => NSWeekCalendarUnit, + _ => throw ArgumentError("Unknown value for NSCalendarUnit: $value"), + }; + + @override + String toString() { + if (this == NSCalendarUnitEra) + return "NSCalendarUnit.NSCalendarUnitEra, NSCalendarUnit.NSEraCalendarUnit"; + if (this == NSCalendarUnitYear) + return "NSCalendarUnit.NSCalendarUnitYear, NSCalendarUnit.NSYearCalendarUnit"; + if (this == NSCalendarUnitMonth) + return "NSCalendarUnit.NSCalendarUnitMonth, NSCalendarUnit.NSMonthCalendarUnit"; + if (this == NSCalendarUnitDay) + return "NSCalendarUnit.NSCalendarUnitDay, NSCalendarUnit.NSDayCalendarUnit"; + if (this == NSCalendarUnitHour) + return "NSCalendarUnit.NSCalendarUnitHour, NSCalendarUnit.NSHourCalendarUnit"; + if (this == NSCalendarUnitMinute) + return "NSCalendarUnit.NSCalendarUnitMinute, NSCalendarUnit.NSMinuteCalendarUnit"; + if (this == NSCalendarUnitSecond) + return "NSCalendarUnit.NSCalendarUnitSecond, NSCalendarUnit.NSSecondCalendarUnit"; + if (this == NSCalendarUnitWeekday) + return "NSCalendarUnit.NSCalendarUnitWeekday, NSCalendarUnit.NSWeekdayCalendarUnit"; + if (this == NSCalendarUnitWeekdayOrdinal) + return "NSCalendarUnit.NSCalendarUnitWeekdayOrdinal, NSCalendarUnit.NSWeekdayOrdinalCalendarUnit"; + if (this == NSCalendarUnitQuarter) + return "NSCalendarUnit.NSCalendarUnitQuarter, NSCalendarUnit.NSQuarterCalendarUnit"; + if (this == NSCalendarUnitWeekOfMonth) + return "NSCalendarUnit.NSCalendarUnitWeekOfMonth, NSCalendarUnit.NSWeekOfMonthCalendarUnit"; + if (this == NSCalendarUnitWeekOfYear) + return "NSCalendarUnit.NSCalendarUnitWeekOfYear, NSCalendarUnit.NSWeekOfYearCalendarUnit"; + if (this == NSCalendarUnitYearForWeekOfYear) + return "NSCalendarUnit.NSCalendarUnitYearForWeekOfYear, NSCalendarUnit.NSYearForWeekOfYearCalendarUnit"; + if (this == NSCalendarUnitCalendar) + return "NSCalendarUnit.NSCalendarUnitCalendar, NSCalendarUnit.NSCalendarCalendarUnit"; + if (this == NSCalendarUnitTimeZone) + return "NSCalendarUnit.NSCalendarUnitTimeZone, NSCalendarUnit.NSTimeZoneCalendarUnit"; + return super.toString(); + } +} + +late final _sel_repeatInterval = objc.registerName("repeatInterval"); +final _objc_msgSend_600 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setRepeatInterval_ = objc.registerName("setRepeatInterval:"); +final _objc_msgSend_601 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +/// NSCalendar +class NSCalendar extends objc.NSObject { + NSCalendar._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSCalendar] that points to the same underlying object as [other]. + NSCalendar.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSCalendar] that wraps the given raw object pointer. + NSCalendar.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSCalendar]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSCalendar); + } + + /// currentCalendar + static NSCalendar getCurrentCalendar() { + final _ret = _objc_msgSend_602(_class_NSCalendar, _sel_currentCalendar); + return NSCalendar.castFromPointer(_ret, retain: true, release: true); + } + + /// autoupdatingCurrentCalendar + static NSCalendar getAutoupdatingCurrentCalendar() { + final _ret = + _objc_msgSend_602(_class_NSCalendar, _sel_autoupdatingCurrentCalendar); + return NSCalendar.castFromPointer(_ret, retain: true, release: true); + } + + /// calendarWithIdentifier: + static NSCalendar? calendarWithIdentifier_( + objc.NSString calendarIdentifierConstant) { + final _ret = _objc_msgSend_603(_class_NSCalendar, + _sel_calendarWithIdentifier_, calendarIdentifierConstant.pointer); + return _ret.address == 0 + ? null + : NSCalendar.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSCalendar init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSCalendar.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCalendarIdentifier: + objc.ObjCObjectBase? initWithCalendarIdentifier_(objc.NSString ident) { + final _ret = _objc_msgSend_57( + this.pointer, _sel_initWithCalendarIdentifier_, ident.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// calendarIdentifier + objc.NSString get calendarIdentifier { + final _ret = _objc_msgSend_77(this.pointer, _sel_calendarIdentifier); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// locale + objc.NSLocale? get locale { + final _ret = _objc_msgSend_168(this.pointer, _sel_locale); + return _ret.address == 0 + ? null + : objc.NSLocale.castFromPointer(_ret, retain: true, release: true); + } + + /// setLocale: + set locale(objc.NSLocale? value) { + return _objc_msgSend_604( + this.pointer, _sel_setLocale_, value?.pointer ?? ffi.nullptr); + } + + /// timeZone + NSTimeZone get timeZone { + final _ret = _objc_msgSend_605(this.pointer, _sel_timeZone); + return NSTimeZone.castFromPointer(_ret, retain: true, release: true); + } + + /// setTimeZone: + set timeZone(NSTimeZone value) { + return _objc_msgSend_606(this.pointer, _sel_setTimeZone_, value.pointer); + } + + /// firstWeekday + int get firstWeekday { + return _objc_msgSend_42(this.pointer, _sel_firstWeekday); + } + + /// setFirstWeekday: + set firstWeekday(int value) { + return _objc_msgSend_369(this.pointer, _sel_setFirstWeekday_, value); + } + + /// minimumDaysInFirstWeek + int get minimumDaysInFirstWeek { + return _objc_msgSend_42(this.pointer, _sel_minimumDaysInFirstWeek); + } + + /// setMinimumDaysInFirstWeek: + set minimumDaysInFirstWeek(int value) { + return _objc_msgSend_369( + this.pointer, _sel_setMinimumDaysInFirstWeek_, value); + } + + /// eraSymbols + objc.NSArray get eraSymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_eraSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// longEraSymbols + objc.NSArray get longEraSymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_longEraSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// monthSymbols + objc.NSArray get monthSymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_monthSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// shortMonthSymbols + objc.NSArray get shortMonthSymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_shortMonthSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// veryShortMonthSymbols + objc.NSArray get veryShortMonthSymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_veryShortMonthSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// standaloneMonthSymbols + objc.NSArray get standaloneMonthSymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_standaloneMonthSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// shortStandaloneMonthSymbols + objc.NSArray get shortStandaloneMonthSymbols { + final _ret = + _objc_msgSend_14(this.pointer, _sel_shortStandaloneMonthSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// veryShortStandaloneMonthSymbols + objc.NSArray get veryShortStandaloneMonthSymbols { + final _ret = + _objc_msgSend_14(this.pointer, _sel_veryShortStandaloneMonthSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// weekdaySymbols + objc.NSArray get weekdaySymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_weekdaySymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// shortWeekdaySymbols + objc.NSArray get shortWeekdaySymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_shortWeekdaySymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// veryShortWeekdaySymbols + objc.NSArray get veryShortWeekdaySymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_veryShortWeekdaySymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// standaloneWeekdaySymbols + objc.NSArray get standaloneWeekdaySymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_standaloneWeekdaySymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// shortStandaloneWeekdaySymbols + objc.NSArray get shortStandaloneWeekdaySymbols { + final _ret = + _objc_msgSend_14(this.pointer, _sel_shortStandaloneWeekdaySymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// veryShortStandaloneWeekdaySymbols + objc.NSArray get veryShortStandaloneWeekdaySymbols { + final _ret = + _objc_msgSend_14(this.pointer, _sel_veryShortStandaloneWeekdaySymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// quarterSymbols + objc.NSArray get quarterSymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_quarterSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// shortQuarterSymbols + objc.NSArray get shortQuarterSymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_shortQuarterSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// standaloneQuarterSymbols + objc.NSArray get standaloneQuarterSymbols { + final _ret = _objc_msgSend_14(this.pointer, _sel_standaloneQuarterSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// shortStandaloneQuarterSymbols + objc.NSArray get shortStandaloneQuarterSymbols { + final _ret = + _objc_msgSend_14(this.pointer, _sel_shortStandaloneQuarterSymbols); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// AMSymbol + objc.NSString get AMSymbol { + final _ret = _objc_msgSend_77(this.pointer, _sel_AMSymbol); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// PMSymbol + objc.NSString get PMSymbol { + final _ret = _objc_msgSend_77(this.pointer, _sel_PMSymbol); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// minimumRangeOfUnit: + void minimumRangeOfUnit_(ffi.Pointer<_NSRange> stret, NSCalendarUnit unit) { + objc.useMsgSendVariants + ? _objc_msgSend_607Stret( + stret, this.pointer, _sel_minimumRangeOfUnit_, unit.value) + : stret.ref = _objc_msgSend_607( + this.pointer, _sel_minimumRangeOfUnit_, unit.value); + } + + /// maximumRangeOfUnit: + void maximumRangeOfUnit_(ffi.Pointer<_NSRange> stret, NSCalendarUnit unit) { + objc.useMsgSendVariants + ? _objc_msgSend_607Stret( + stret, this.pointer, _sel_maximumRangeOfUnit_, unit.value) + : stret.ref = _objc_msgSend_607( + this.pointer, _sel_maximumRangeOfUnit_, unit.value); + } + + /// rangeOfUnit:inUnit:forDate: + void rangeOfUnit_inUnit_forDate_(ffi.Pointer<_NSRange> stret, + NSCalendarUnit smaller, NSCalendarUnit larger, objc.NSDate date) { + objc.useMsgSendVariants + ? _objc_msgSend_608Stret( + stret, + this.pointer, + _sel_rangeOfUnit_inUnit_forDate_, + smaller.value, + larger.value, + date.pointer) + : stret.ref = _objc_msgSend_608( + this.pointer, + _sel_rangeOfUnit_inUnit_forDate_, + smaller.value, + larger.value, + date.pointer); + } + + /// ordinalityOfUnit:inUnit:forDate: + int ordinalityOfUnit_inUnit_forDate_( + NSCalendarUnit smaller, NSCalendarUnit larger, objc.NSDate date) { + return _objc_msgSend_609( + this.pointer, + _sel_ordinalityOfUnit_inUnit_forDate_, + smaller.value, + larger.value, + date.pointer); + } + + /// rangeOfUnit:startDate:interval:forDate: + bool rangeOfUnit_startDate_interval_forDate_( + NSCalendarUnit unit, + ffi.Pointer> datep, + ffi.Pointer tip, + objc.NSDate date) { + return _objc_msgSend_610( + this.pointer, + _sel_rangeOfUnit_startDate_interval_forDate_, + unit.value, + datep, + tip, + date.pointer); + } + + /// dateFromComponents: + objc.NSDate? dateFromComponents_(NSDateComponents comps) { + final _ret = _objc_msgSend_617( + this.pointer, _sel_dateFromComponents_, comps.pointer); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// components:fromDate: + NSDateComponents components_fromDate_( + NSCalendarUnit unitFlags, objc.NSDate date) { + final _ret = _objc_msgSend_618( + this.pointer, _sel_components_fromDate_, unitFlags.value, date.pointer); + return NSDateComponents.castFromPointer(_ret, retain: true, release: true); + } + + /// dateByAddingComponents:toDate:options: + objc.NSDate? dateByAddingComponents_toDate_options_( + NSDateComponents comps, objc.NSDate date, NSCalendarOptions opts) { + final _ret = _objc_msgSend_619( + this.pointer, + _sel_dateByAddingComponents_toDate_options_, + comps.pointer, + date.pointer, + opts.value); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// components:fromDate:toDate:options: + NSDateComponents components_fromDate_toDate_options_( + NSCalendarUnit unitFlags, + objc.NSDate startingDate, + objc.NSDate resultDate, + NSCalendarOptions opts) { + final _ret = _objc_msgSend_620( + this.pointer, + _sel_components_fromDate_toDate_options_, + unitFlags.value, + startingDate.pointer, + resultDate.pointer, + opts.value); + return NSDateComponents.castFromPointer(_ret, retain: true, release: true); + } + + /// getEra:year:month:day:fromDate: + void getEra_year_month_day_fromDate_( + ffi.Pointer eraValuePointer, + ffi.Pointer yearValuePointer, + ffi.Pointer monthValuePointer, + ffi.Pointer dayValuePointer, + objc.NSDate date) { + _objc_msgSend_621( + this.pointer, + _sel_getEra_year_month_day_fromDate_, + eraValuePointer, + yearValuePointer, + monthValuePointer, + dayValuePointer, + date.pointer); + } + + /// getEra:yearForWeekOfYear:weekOfYear:weekday:fromDate: + void getEra_yearForWeekOfYear_weekOfYear_weekday_fromDate_( + ffi.Pointer eraValuePointer, + ffi.Pointer yearValuePointer, + ffi.Pointer weekValuePointer, + ffi.Pointer weekdayValuePointer, + objc.NSDate date) { + _objc_msgSend_621( + this.pointer, + _sel_getEra_yearForWeekOfYear_weekOfYear_weekday_fromDate_, + eraValuePointer, + yearValuePointer, + weekValuePointer, + weekdayValuePointer, + date.pointer); + } + + /// getHour:minute:second:nanosecond:fromDate: + void getHour_minute_second_nanosecond_fromDate_( + ffi.Pointer hourValuePointer, + ffi.Pointer minuteValuePointer, + ffi.Pointer secondValuePointer, + ffi.Pointer nanosecondValuePointer, + objc.NSDate date) { + _objc_msgSend_621( + this.pointer, + _sel_getHour_minute_second_nanosecond_fromDate_, + hourValuePointer, + minuteValuePointer, + secondValuePointer, + nanosecondValuePointer, + date.pointer); + } + + /// component:fromDate: + int component_fromDate_(NSCalendarUnit unit, objc.NSDate date) { + return _objc_msgSend_622( + this.pointer, _sel_component_fromDate_, unit.value, date.pointer); + } + + /// dateWithEra:year:month:day:hour:minute:second:nanosecond: + objc.NSDate? dateWithEra_year_month_day_hour_minute_second_nanosecond_( + int eraValue, + int yearValue, + int monthValue, + int dayValue, + int hourValue, + int minuteValue, + int secondValue, + int nanosecondValue) { + final _ret = _objc_msgSend_623( + this.pointer, + _sel_dateWithEra_year_month_day_hour_minute_second_nanosecond_, + eraValue, + yearValue, + monthValue, + dayValue, + hourValue, + minuteValue, + secondValue, + nanosecondValue); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// dateWithEra:yearForWeekOfYear:weekOfYear:weekday:hour:minute:second:nanosecond: + objc.NSDate? + dateWithEra_yearForWeekOfYear_weekOfYear_weekday_hour_minute_second_nanosecond_( + int eraValue, + int yearValue, + int weekValue, + int weekdayValue, + int hourValue, + int minuteValue, + int secondValue, + int nanosecondValue) { + final _ret = _objc_msgSend_623( + this.pointer, + _sel_dateWithEra_yearForWeekOfYear_weekOfYear_weekday_hour_minute_second_nanosecond_, + eraValue, + yearValue, + weekValue, + weekdayValue, + hourValue, + minuteValue, + secondValue, + nanosecondValue); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// startOfDayForDate: + objc.NSDate startOfDayForDate_(objc.NSDate date) { + final _ret = + _objc_msgSend_624(this.pointer, _sel_startOfDayForDate_, date.pointer); + return objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// componentsInTimeZone:fromDate: + NSDateComponents componentsInTimeZone_fromDate_( + NSTimeZone timezone, objc.NSDate date) { + final _ret = _objc_msgSend_625(this.pointer, + _sel_componentsInTimeZone_fromDate_, timezone.pointer, date.pointer); + return NSDateComponents.castFromPointer(_ret, retain: true, release: true); + } + + /// compareDate:toDate:toUnitGranularity: + objc.NSComparisonResult compareDate_toDate_toUnitGranularity_( + objc.NSDate date1, objc.NSDate date2, NSCalendarUnit unit) { + final _ret = _objc_msgSend_626( + this.pointer, + _sel_compareDate_toDate_toUnitGranularity_, + date1.pointer, + date2.pointer, + unit.value); + return objc.NSComparisonResult.fromValue(_ret); + } + + /// isDate:equalToDate:toUnitGranularity: + bool isDate_equalToDate_toUnitGranularity_( + objc.NSDate date1, objc.NSDate date2, NSCalendarUnit unit) { + return _objc_msgSend_627( + this.pointer, + _sel_isDate_equalToDate_toUnitGranularity_, + date1.pointer, + date2.pointer, + unit.value); + } + + /// isDate:inSameDayAsDate: + bool isDate_inSameDayAsDate_(objc.NSDate date1, objc.NSDate date2) { + return _objc_msgSend_628(this.pointer, _sel_isDate_inSameDayAsDate_, + date1.pointer, date2.pointer); + } + + /// isDateInToday: + bool isDateInToday_(objc.NSDate date) { + return _objc_msgSend_595(this.pointer, _sel_isDateInToday_, date.pointer); + } + + /// isDateInYesterday: + bool isDateInYesterday_(objc.NSDate date) { + return _objc_msgSend_595( + this.pointer, _sel_isDateInYesterday_, date.pointer); + } + + /// isDateInTomorrow: + bool isDateInTomorrow_(objc.NSDate date) { + return _objc_msgSend_595( + this.pointer, _sel_isDateInTomorrow_, date.pointer); + } + + /// isDateInWeekend: + bool isDateInWeekend_(objc.NSDate date) { + return _objc_msgSend_595(this.pointer, _sel_isDateInWeekend_, date.pointer); + } + + /// rangeOfWeekendStartDate:interval:containingDate: + bool rangeOfWeekendStartDate_interval_containingDate_( + ffi.Pointer> datep, + ffi.Pointer tip, + objc.NSDate date) { + return _objc_msgSend_629( + this.pointer, + _sel_rangeOfWeekendStartDate_interval_containingDate_, + datep, + tip, + date.pointer); + } + + /// nextWeekendStartDate:interval:options:afterDate: + bool nextWeekendStartDate_interval_options_afterDate_( + ffi.Pointer> datep, + ffi.Pointer tip, + NSCalendarOptions options, + objc.NSDate date) { + return _objc_msgSend_630( + this.pointer, + _sel_nextWeekendStartDate_interval_options_afterDate_, + datep, + tip, + options.value, + date.pointer); + } + + /// components:fromDateComponents:toDateComponents:options: + NSDateComponents components_fromDateComponents_toDateComponents_options_( + NSCalendarUnit unitFlags, + NSDateComponents startingDateComp, + NSDateComponents resultDateComp, + NSCalendarOptions options) { + final _ret = _objc_msgSend_631( + this.pointer, + _sel_components_fromDateComponents_toDateComponents_options_, + unitFlags.value, + startingDateComp.pointer, + resultDateComp.pointer, + options.value); + return NSDateComponents.castFromPointer(_ret, retain: true, release: true); + } + + /// dateByAddingUnit:value:toDate:options: + objc.NSDate? dateByAddingUnit_value_toDate_options_(NSCalendarUnit unit, + int value, objc.NSDate date, NSCalendarOptions options) { + final _ret = _objc_msgSend_632( + this.pointer, + _sel_dateByAddingUnit_value_toDate_options_, + unit.value, + value, + date.pointer, + options.value); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// enumerateDatesStartingAfterDate:matchingComponents:options:usingBlock: + void enumerateDatesStartingAfterDate_matchingComponents_options_usingBlock_( + objc.NSDate start, + NSDateComponents comps, + NSCalendarOptions opts, + ObjCBlock_ffiVoid_NSDate_bool_bool block) { + _objc_msgSend_633( + this.pointer, + _sel_enumerateDatesStartingAfterDate_matchingComponents_options_usingBlock_, + start.pointer, + comps.pointer, + opts.value, + block.pointer); + } + + /// nextDateAfterDate:matchingComponents:options: + objc.NSDate? nextDateAfterDate_matchingComponents_options_( + objc.NSDate date, NSDateComponents comps, NSCalendarOptions options) { + final _ret = _objc_msgSend_634( + this.pointer, + _sel_nextDateAfterDate_matchingComponents_options_, + date.pointer, + comps.pointer, + options.value); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// nextDateAfterDate:matchingUnit:value:options: + objc.NSDate? nextDateAfterDate_matchingUnit_value_options_(objc.NSDate date, + NSCalendarUnit unit, int value, NSCalendarOptions options) { + final _ret = _objc_msgSend_635( + this.pointer, + _sel_nextDateAfterDate_matchingUnit_value_options_, + date.pointer, + unit.value, + value, + options.value); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// nextDateAfterDate:matchingHour:minute:second:options: + objc.NSDate? nextDateAfterDate_matchingHour_minute_second_options_( + objc.NSDate date, + int hourValue, + int minuteValue, + int secondValue, + NSCalendarOptions options) { + final _ret = _objc_msgSend_636( + this.pointer, + _sel_nextDateAfterDate_matchingHour_minute_second_options_, + date.pointer, + hourValue, + minuteValue, + secondValue, + options.value); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// dateBySettingUnit:value:ofDate:options: + objc.NSDate? dateBySettingUnit_value_ofDate_options_( + NSCalendarUnit unit, int v, objc.NSDate date, NSCalendarOptions opts) { + final _ret = _objc_msgSend_632( + this.pointer, + _sel_dateBySettingUnit_value_ofDate_options_, + unit.value, + v, + date.pointer, + opts.value); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// dateBySettingHour:minute:second:ofDate:options: + objc.NSDate? dateBySettingHour_minute_second_ofDate_options_( + int h, int m, int s, objc.NSDate date, NSCalendarOptions opts) { + final _ret = _objc_msgSend_637( + this.pointer, + _sel_dateBySettingHour_minute_second_ofDate_options_, + h, + m, + s, + date.pointer, + opts.value); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// date:matchesComponents: + bool date_matchesComponents_(objc.NSDate date, NSDateComponents components) { + return _objc_msgSend_638(this.pointer, _sel_date_matchesComponents_, + date.pointer, components.pointer); + } + + /// new + static NSCalendar new1() { + final _ret = _objc_msgSend_18(_class_NSCalendar, _sel_new); + return NSCalendar.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSCalendar allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19(_class_NSCalendar, _sel_allocWithZone_, zone); + return NSCalendar.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSCalendar alloc() { + final _ret = _objc_msgSend_18(_class_NSCalendar, _sel_alloc); + return NSCalendar.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSCalendar = objc.getClass("NSCalendar"); +late final _sel_currentCalendar = objc.registerName("currentCalendar"); +final _objc_msgSend_602 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_autoupdatingCurrentCalendar = + objc.registerName("autoupdatingCurrentCalendar"); +late final _sel_calendarWithIdentifier_ = + objc.registerName("calendarWithIdentifier:"); +final _objc_msgSend_603 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithCalendarIdentifier_ = + objc.registerName("initWithCalendarIdentifier:"); +late final _sel_calendarIdentifier = objc.registerName("calendarIdentifier"); +late final _sel_setLocale_ = objc.registerName("setLocale:"); +final _objc_msgSend_604 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_605 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_606 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_firstWeekday = objc.registerName("firstWeekday"); +late final _sel_setFirstWeekday_ = objc.registerName("setFirstWeekday:"); +late final _sel_minimumDaysInFirstWeek = + objc.registerName("minimumDaysInFirstWeek"); +late final _sel_setMinimumDaysInFirstWeek_ = + objc.registerName("setMinimumDaysInFirstWeek:"); +late final _sel_eraSymbols = objc.registerName("eraSymbols"); +late final _sel_longEraSymbols = objc.registerName("longEraSymbols"); +late final _sel_monthSymbols = objc.registerName("monthSymbols"); +late final _sel_shortMonthSymbols = objc.registerName("shortMonthSymbols"); +late final _sel_veryShortMonthSymbols = + objc.registerName("veryShortMonthSymbols"); +late final _sel_standaloneMonthSymbols = + objc.registerName("standaloneMonthSymbols"); +late final _sel_shortStandaloneMonthSymbols = + objc.registerName("shortStandaloneMonthSymbols"); +late final _sel_veryShortStandaloneMonthSymbols = + objc.registerName("veryShortStandaloneMonthSymbols"); +late final _sel_weekdaySymbols = objc.registerName("weekdaySymbols"); +late final _sel_shortWeekdaySymbols = objc.registerName("shortWeekdaySymbols"); +late final _sel_veryShortWeekdaySymbols = + objc.registerName("veryShortWeekdaySymbols"); +late final _sel_standaloneWeekdaySymbols = + objc.registerName("standaloneWeekdaySymbols"); +late final _sel_shortStandaloneWeekdaySymbols = + objc.registerName("shortStandaloneWeekdaySymbols"); +late final _sel_veryShortStandaloneWeekdaySymbols = + objc.registerName("veryShortStandaloneWeekdaySymbols"); +late final _sel_quarterSymbols = objc.registerName("quarterSymbols"); +late final _sel_shortQuarterSymbols = objc.registerName("shortQuarterSymbols"); +late final _sel_standaloneQuarterSymbols = + objc.registerName("standaloneQuarterSymbols"); +late final _sel_shortStandaloneQuarterSymbols = + objc.registerName("shortStandaloneQuarterSymbols"); +late final _sel_AMSymbol = objc.registerName("AMSymbol"); +late final _sel_PMSymbol = objc.registerName("PMSymbol"); +late final _sel_minimumRangeOfUnit_ = objc.registerName("minimumRangeOfUnit:"); +final _objc_msgSend_607 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + _NSRange Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + _NSRange Function(ffi.Pointer, + ffi.Pointer, int)>(); +final _objc_msgSend_607Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer<_NSRange>, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer<_NSRange>, ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_maximumRangeOfUnit_ = objc.registerName("maximumRangeOfUnit:"); +late final _sel_rangeOfUnit_inUnit_forDate_ = + objc.registerName("rangeOfUnit:inUnit:forDate:"); +final _objc_msgSend_608 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + _NSRange Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + _NSRange Function( + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer)>(); +final _objc_msgSend_608Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer<_NSRange>, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer<_NSRange>, + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer)>(); +late final _sel_ordinalityOfUnit_inUnit_forDate_ = + objc.registerName("ordinalityOfUnit:inUnit:forDate:"); +final _objc_msgSend_609 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer)>(); +late final _sel_rangeOfUnit_startDate_interval_forDate_ = + objc.registerName("rangeOfUnit:startDate:interval:forDate:"); +final _objc_msgSend_610 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer>, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer>, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSDateComponents +class NSDateComponents extends objc.NSObject { + NSDateComponents._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSDateComponents] that points to the same underlying object as [other]. + NSDateComponents.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSDateComponents] that wraps the given raw object pointer. + NSDateComponents.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSDateComponents]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSDateComponents); + } + + /// calendar + NSCalendar? get calendar { + final _ret = _objc_msgSend_611(this.pointer, _sel_calendar); + return _ret.address == 0 + ? null + : NSCalendar.castFromPointer(_ret, retain: true, release: true); + } + + /// setCalendar: + set calendar(NSCalendar? value) { + return _objc_msgSend_612( + this.pointer, _sel_setCalendar_, value?.pointer ?? ffi.nullptr); + } + + /// timeZone + NSTimeZone? get timeZone { + final _ret = _objc_msgSend_598(this.pointer, _sel_timeZone); + return _ret.address == 0 + ? null + : NSTimeZone.castFromPointer(_ret, retain: true, release: true); + } + + /// setTimeZone: + set timeZone(NSTimeZone? value) { + return _objc_msgSend_599( + this.pointer, _sel_setTimeZone_, value?.pointer ?? ffi.nullptr); + } + + /// era + int get era { + return _objc_msgSend_48(this.pointer, _sel_era); + } + + /// setEra: + set era(int value) { + return _objc_msgSend_49(this.pointer, _sel_setEra_, value); + } + + /// year + int get year { + return _objc_msgSend_48(this.pointer, _sel_year); + } + + /// setYear: + set year(int value) { + return _objc_msgSend_49(this.pointer, _sel_setYear_, value); + } + + /// month + int get month { + return _objc_msgSend_48(this.pointer, _sel_month); + } + + /// setMonth: + set month(int value) { + return _objc_msgSend_49(this.pointer, _sel_setMonth_, value); + } + + /// day + int get day { + return _objc_msgSend_48(this.pointer, _sel_day); + } + + /// setDay: + set day(int value) { + return _objc_msgSend_49(this.pointer, _sel_setDay_, value); + } + + /// hour + int get hour { + return _objc_msgSend_48(this.pointer, _sel_hour); + } + + /// setHour: + set hour(int value) { + return _objc_msgSend_49(this.pointer, _sel_setHour_, value); + } + + /// minute + int get minute { + return _objc_msgSend_48(this.pointer, _sel_minute); + } + + /// setMinute: + set minute(int value) { + return _objc_msgSend_49(this.pointer, _sel_setMinute_, value); + } + + /// second + int get second { + return _objc_msgSend_48(this.pointer, _sel_second); + } + + /// setSecond: + set second(int value) { + return _objc_msgSend_49(this.pointer, _sel_setSecond_, value); + } + + /// nanosecond + int get nanosecond { + return _objc_msgSend_48(this.pointer, _sel_nanosecond); + } + + /// setNanosecond: + set nanosecond(int value) { + return _objc_msgSend_49(this.pointer, _sel_setNanosecond_, value); + } + + /// weekday + int get weekday { + return _objc_msgSend_48(this.pointer, _sel_weekday); + } + + /// setWeekday: + set weekday(int value) { + return _objc_msgSend_49(this.pointer, _sel_setWeekday_, value); + } + + /// weekdayOrdinal + int get weekdayOrdinal { + return _objc_msgSend_48(this.pointer, _sel_weekdayOrdinal); + } + + /// setWeekdayOrdinal: + set weekdayOrdinal(int value) { + return _objc_msgSend_49(this.pointer, _sel_setWeekdayOrdinal_, value); + } + + /// quarter + int get quarter { + return _objc_msgSend_48(this.pointer, _sel_quarter); + } + + /// setQuarter: + set quarter(int value) { + return _objc_msgSend_49(this.pointer, _sel_setQuarter_, value); + } + + /// weekOfMonth + int get weekOfMonth { + return _objc_msgSend_48(this.pointer, _sel_weekOfMonth); + } + + /// setWeekOfMonth: + set weekOfMonth(int value) { + return _objc_msgSend_49(this.pointer, _sel_setWeekOfMonth_, value); + } + + /// weekOfYear + int get weekOfYear { + return _objc_msgSend_48(this.pointer, _sel_weekOfYear); + } + + /// setWeekOfYear: + set weekOfYear(int value) { + return _objc_msgSend_49(this.pointer, _sel_setWeekOfYear_, value); + } + + /// yearForWeekOfYear + int get yearForWeekOfYear { + return _objc_msgSend_48(this.pointer, _sel_yearForWeekOfYear); + } + + /// setYearForWeekOfYear: + set yearForWeekOfYear(int value) { + return _objc_msgSend_49(this.pointer, _sel_setYearForWeekOfYear_, value); + } + + /// isLeapMonth + bool get leapMonth { + return _objc_msgSend_5(this.pointer, _sel_isLeapMonth); + } + + /// setLeapMonth: + set leapMonth(bool value) { + return _objc_msgSend_6(this.pointer, _sel_setLeapMonth_, value); + } + + /// date + objc.NSDate? get date { + final _ret = _objc_msgSend_517(this.pointer, _sel_date); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// week + int week() { + return _objc_msgSend_48(this.pointer, _sel_week); + } + + /// setWeek: + void setWeek_(int v) { + _objc_msgSend_613(this.pointer, _sel_setWeek_, v); + } + + /// setValue:forComponent: + void setValue_forComponent_(int value, NSCalendarUnit unit) { + _objc_msgSend_614( + this.pointer, _sel_setValue_forComponent_, value, unit.value); + } + + /// valueForComponent: + int valueForComponent_(NSCalendarUnit unit) { + return _objc_msgSend_615(this.pointer, _sel_valueForComponent_, unit.value); + } + + /// isValidDate + bool get validDate { + return _objc_msgSend_5(this.pointer, _sel_isValidDate); + } + + /// isValidDateInCalendar: + bool isValidDateInCalendar_(NSCalendar calendar) { + return _objc_msgSend_616( + this.pointer, _sel_isValidDateInCalendar_, calendar.pointer); + } + + /// init + NSDateComponents init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return NSDateComponents.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSDateComponents new1() { + final _ret = _objc_msgSend_18(_class_NSDateComponents, _sel_new); + return NSDateComponents.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSDateComponents allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_19(_class_NSDateComponents, _sel_allocWithZone_, zone); + return NSDateComponents.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSDateComponents alloc() { + final _ret = _objc_msgSend_18(_class_NSDateComponents, _sel_alloc); + return NSDateComponents.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSDateComponents = objc.getClass("NSDateComponents"); +late final _sel_calendar = objc.registerName("calendar"); +final _objc_msgSend_611 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setCalendar_ = objc.registerName("setCalendar:"); +final _objc_msgSend_612 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_era = objc.registerName("era"); +late final _sel_setEra_ = objc.registerName("setEra:"); +late final _sel_year = objc.registerName("year"); +late final _sel_setYear_ = objc.registerName("setYear:"); +late final _sel_month = objc.registerName("month"); +late final _sel_setMonth_ = objc.registerName("setMonth:"); +late final _sel_day = objc.registerName("day"); +late final _sel_setDay_ = objc.registerName("setDay:"); +late final _sel_hour = objc.registerName("hour"); +late final _sel_setHour_ = objc.registerName("setHour:"); +late final _sel_minute = objc.registerName("minute"); +late final _sel_setMinute_ = objc.registerName("setMinute:"); +late final _sel_second = objc.registerName("second"); +late final _sel_setSecond_ = objc.registerName("setSecond:"); +late final _sel_nanosecond = objc.registerName("nanosecond"); +late final _sel_setNanosecond_ = objc.registerName("setNanosecond:"); +late final _sel_weekday = objc.registerName("weekday"); +late final _sel_setWeekday_ = objc.registerName("setWeekday:"); +late final _sel_weekdayOrdinal = objc.registerName("weekdayOrdinal"); +late final _sel_setWeekdayOrdinal_ = objc.registerName("setWeekdayOrdinal:"); +late final _sel_quarter = objc.registerName("quarter"); +late final _sel_setQuarter_ = objc.registerName("setQuarter:"); +late final _sel_weekOfMonth = objc.registerName("weekOfMonth"); +late final _sel_setWeekOfMonth_ = objc.registerName("setWeekOfMonth:"); +late final _sel_weekOfYear = objc.registerName("weekOfYear"); +late final _sel_setWeekOfYear_ = objc.registerName("setWeekOfYear:"); +late final _sel_yearForWeekOfYear = objc.registerName("yearForWeekOfYear"); +late final _sel_setYearForWeekOfYear_ = + objc.registerName("setYearForWeekOfYear:"); +late final _sel_isLeapMonth = objc.registerName("isLeapMonth"); +late final _sel_setLeapMonth_ = objc.registerName("setLeapMonth:"); +late final _sel_date = objc.registerName("date"); +late final _sel_week = objc.registerName("week"); +late final _sel_setWeek_ = objc.registerName("setWeek:"); +final _objc_msgSend_613 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_setValue_forComponent_ = + objc.registerName("setValue:forComponent:"); +final _objc_msgSend_614 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int, int)>(); +late final _sel_valueForComponent_ = objc.registerName("valueForComponent:"); +final _objc_msgSend_615 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_isValidDate = objc.registerName("isValidDate"); +late final _sel_isValidDateInCalendar_ = + objc.registerName("isValidDateInCalendar:"); +final _objc_msgSend_616 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_dateFromComponents_ = objc.registerName("dateFromComponents:"); +final _objc_msgSend_617 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_components_fromDate_ = + objc.registerName("components:fromDate:"); +final _objc_msgSend_618 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); + +enum NSCalendarOptions { + NSCalendarWrapComponents(1), + NSCalendarMatchStrictly(2), + NSCalendarSearchBackwards(4), + NSCalendarMatchPreviousTimePreservingSmallerUnits(256), + NSCalendarMatchNextTimePreservingSmallerUnits(512), + NSCalendarMatchNextTime(1024), + NSCalendarMatchFirst(4096), + NSCalendarMatchLast(8192); + + final int value; + const NSCalendarOptions(this.value); + + static NSCalendarOptions fromValue(int value) => switch (value) { + 1 => NSCalendarWrapComponents, + 2 => NSCalendarMatchStrictly, + 4 => NSCalendarSearchBackwards, + 256 => NSCalendarMatchPreviousTimePreservingSmallerUnits, + 512 => NSCalendarMatchNextTimePreservingSmallerUnits, + 1024 => NSCalendarMatchNextTime, + 4096 => NSCalendarMatchFirst, + 8192 => NSCalendarMatchLast, + _ => throw ArgumentError("Unknown value for NSCalendarOptions: $value"), + }; +} + +late final _sel_dateByAddingComponents_toDate_options_ = + objc.registerName("dateByAddingComponents:toDate:options:"); +final _objc_msgSend_619 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_components_fromDate_toDate_options_ = + objc.registerName("components:fromDate:toDate:options:"); +final _objc_msgSend_620 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_getEra_year_month_day_fromDate_ = + objc.registerName("getEra:year:month:day:fromDate:"); +final _objc_msgSend_621 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_getEra_yearForWeekOfYear_weekOfYear_weekday_fromDate_ = + objc.registerName("getEra:yearForWeekOfYear:weekOfYear:weekday:fromDate:"); +late final _sel_getHour_minute_second_nanosecond_fromDate_ = + objc.registerName("getHour:minute:second:nanosecond:fromDate:"); +late final _sel_component_fromDate_ = objc.registerName("component:fromDate:"); +final _objc_msgSend_622 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_dateWithEra_year_month_day_hour_minute_second_nanosecond_ = objc + .registerName("dateWithEra:year:month:day:hour:minute:second:nanosecond:"); +final _objc_msgSend_623 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Long, + ffi.Long, + ffi.Long, + ffi.Long, + ffi.Long, + ffi.Long, + ffi.Long, + ffi.Long)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + int, + int, + int, + int, + int)>(); +late final _sel_dateWithEra_yearForWeekOfYear_weekOfYear_weekday_hour_minute_second_nanosecond_ = + objc.registerName( + "dateWithEra:yearForWeekOfYear:weekOfYear:weekday:hour:minute:second:nanosecond:"); +late final _sel_startOfDayForDate_ = objc.registerName("startOfDayForDate:"); +final _objc_msgSend_624 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_componentsInTimeZone_fromDate_ = + objc.registerName("componentsInTimeZone:fromDate:"); +final _objc_msgSend_625 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_compareDate_toDate_toUnitGranularity_ = + objc.registerName("compareDate:toDate:toUnitGranularity:"); +final _objc_msgSend_626 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_isDate_equalToDate_toUnitGranularity_ = + objc.registerName("isDate:equalToDate:toUnitGranularity:"); +final _objc_msgSend_627 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_isDate_inSameDayAsDate_ = + objc.registerName("isDate:inSameDayAsDate:"); +final _objc_msgSend_628 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_isDateInToday_ = objc.registerName("isDateInToday:"); +late final _sel_isDateInYesterday_ = objc.registerName("isDateInYesterday:"); +late final _sel_isDateInTomorrow_ = objc.registerName("isDateInTomorrow:"); +late final _sel_isDateInWeekend_ = objc.registerName("isDateInWeekend:"); +late final _sel_rangeOfWeekendStartDate_interval_containingDate_ = + objc.registerName("rangeOfWeekendStartDate:interval:containingDate:"); +final _objc_msgSend_629 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_nextWeekendStartDate_interval_options_afterDate_ = + objc.registerName("nextWeekendStartDate:interval:options:afterDate:"); +final _objc_msgSend_630 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_components_fromDateComponents_toDateComponents_options_ = objc + .registerName("components:fromDateComponents:toDateComponents:options:"); +final _objc_msgSend_631 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_dateByAddingUnit_value_toDate_options_ = + objc.registerName("dateByAddingUnit:value:toDate:options:"); +final _objc_msgSend_632 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Long, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + int, + ffi.Pointer, + int)>(); +void _ObjCBlock_ffiVoid_NSDate_bool_bool_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + bool arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Bool arg1, ffi.Pointer arg2)>>() + .asFunction< + void Function(ffi.Pointer, bool, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_NSDate_bool_bool_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + bool arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function(ffi.Pointer, + bool, ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_NSDate_bool_bool extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSDate_bool_bool._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSDate_bool_bool castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSDate_bool_bool._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSDate_bool_bool.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Bool arg1, ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSDate_bool_bool_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSDate_bool_bool.fromFunction( + void Function(objc.NSDate?, bool, ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSDate_bool_bool_closureTrampoline) + .cast(), + (ffi.Pointer arg0, bool arg1, ffi.Pointer arg2) => + fn(arg0.address == 0 ? null : objc.NSDate.castFromPointer(arg0, retain: true, release: true), + arg1, arg2))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSDate_bool_bool.listener( + void Function(objc.NSDate?, bool, ffi.Pointer) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSDate_bool_bool( + objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSDate_bool_bool_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, bool arg1, + ffi.Pointer arg2) => + fn(arg0.address == 0 ? null : objc.NSDate.castFromPointer(arg0, retain: false, release: true), arg1, arg2)))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(objc.NSDate? arg0, bool arg1, ffi.Pointer arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Bool arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + bool, + ffi.Pointer)>()( + pointer, arg0?.pointer ?? ffi.nullptr, arg1, arg2); +} + +late final _sel_enumerateDatesStartingAfterDate_matchingComponents_options_usingBlock_ = + objc.registerName( + "enumerateDatesStartingAfterDate:matchingComponents:options:usingBlock:"); +final _objc_msgSend_633 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_nextDateAfterDate_matchingComponents_options_ = + objc.registerName("nextDateAfterDate:matchingComponents:options:"); +final _objc_msgSend_634 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_nextDateAfterDate_matchingUnit_value_options_ = + objc.registerName("nextDateAfterDate:matchingUnit:value:options:"); +final _objc_msgSend_635 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Long, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + int)>(); +late final _sel_nextDateAfterDate_matchingHour_minute_second_options_ = + objc.registerName("nextDateAfterDate:matchingHour:minute:second:options:"); +final _objc_msgSend_636 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Long, + ffi.Long, + ffi.Long, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + int)>(); +late final _sel_dateBySettingUnit_value_ofDate_options_ = + objc.registerName("dateBySettingUnit:value:ofDate:options:"); +late final _sel_dateBySettingHour_minute_second_ofDate_options_ = + objc.registerName("dateBySettingHour:minute:second:ofDate:options:"); +final _objc_msgSend_637 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Long, + ffi.Long, + ffi.Long, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + int, + int, + ffi.Pointer, + int)>(); +late final _sel_date_matchesComponents_ = + objc.registerName("date:matchesComponents:"); +final _objc_msgSend_638 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_repeatCalendar = objc.registerName("repeatCalendar"); +late final _sel_setRepeatCalendar_ = objc.registerName("setRepeatCalendar:"); + +/// CLRegion +class CLRegion extends objc.ObjCObjectBase { + CLRegion._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [CLRegion] that points to the same underlying object as [other]. + CLRegion.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CLRegion] that wraps the given raw object pointer. + CLRegion.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CLRegion]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_CLRegion); + } +} + +late final _class_CLRegion = objc.getClass("CLRegion"); +late final _sel_region = objc.registerName("region"); +final _objc_msgSend_639 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setRegion_ = objc.registerName("setRegion:"); +final _objc_msgSend_640 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_regionTriggersOnce = objc.registerName("regionTriggersOnce"); +late final _sel_setRegionTriggersOnce_ = + objc.registerName("setRegionTriggersOnce:"); +late final _sel_alertBody = objc.registerName("alertBody"); +late final _sel_setAlertBody_ = objc.registerName("setAlertBody:"); +late final _sel_hasAction = objc.registerName("hasAction"); +late final _sel_setHasAction_ = objc.registerName("setHasAction:"); +late final _sel_alertAction = objc.registerName("alertAction"); +late final _sel_setAlertAction_ = objc.registerName("setAlertAction:"); +late final _sel_alertLaunchImage = objc.registerName("alertLaunchImage"); +late final _sel_setAlertLaunchImage_ = + objc.registerName("setAlertLaunchImage:"); +late final _sel_alertTitle = objc.registerName("alertTitle"); +late final _sel_setAlertTitle_ = objc.registerName("setAlertTitle:"); +late final _sel_soundName = objc.registerName("soundName"); +late final _sel_setSoundName_ = objc.registerName("setSoundName:"); +late final _sel_category = objc.registerName("category"); +late final _sel_setCategory_ = objc.registerName("setCategory:"); +late final _sel_presentLocalNotificationNow_ = + objc.registerName("presentLocalNotificationNow:"); +final _objc_msgSend_641 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_scheduleLocalNotification_ = + objc.registerName("scheduleLocalNotification:"); +late final _sel_cancelLocalNotification_ = + objc.registerName("cancelLocalNotification:"); +late final _sel_cancelAllLocalNotifications = + objc.registerName("cancelAllLocalNotifications"); +late final _sel_scheduledLocalNotifications = + objc.registerName("scheduledLocalNotifications"); +late final _sel_setScheduledLocalNotifications_ = + objc.registerName("setScheduledLocalNotifications:"); + +/// UIUserNotificationSettings +class UIUserNotificationSettings extends objc.NSObject { + UIUserNotificationSettings._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [UIUserNotificationSettings] that points to the same underlying object as [other]. + UIUserNotificationSettings.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [UIUserNotificationSettings] that wraps the given raw object pointer. + UIUserNotificationSettings.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [UIUserNotificationSettings]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_UIUserNotificationSettings); + } + + /// settingsForTypes:categories: + static UIUserNotificationSettings settingsForTypes_categories_( + UIUserNotificationType types, objc.NSSet? categories) { + final _ret = _objc_msgSend_642( + _class_UIUserNotificationSettings, + _sel_settingsForTypes_categories_, + types.value, + categories?.pointer ?? ffi.nullptr); + return UIUserNotificationSettings.castFromPointer(_ret, + retain: true, release: true); + } + + /// types + UIUserNotificationType get types { + final _ret = _objc_msgSend_643(this.pointer, _sel_types); + return UIUserNotificationType.fromValue(_ret); + } + + /// categories + objc.NSSet? get categories { + final _ret = _objc_msgSend_514(this.pointer, _sel_categories); + return _ret.address == 0 + ? null + : objc.NSSet.castFromPointer(_ret, retain: true, release: true); + } + + /// init + UIUserNotificationSettings init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return UIUserNotificationSettings.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static UIUserNotificationSettings new1() { + final _ret = _objc_msgSend_18(_class_UIUserNotificationSettings, _sel_new); + return UIUserNotificationSettings.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static UIUserNotificationSettings allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_UIUserNotificationSettings, _sel_allocWithZone_, zone); + return UIUserNotificationSettings.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static UIUserNotificationSettings alloc() { + final _ret = + _objc_msgSend_18(_class_UIUserNotificationSettings, _sel_alloc); + return UIUserNotificationSettings.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_UIUserNotificationSettings = + objc.getClass("UIUserNotificationSettings"); + +enum UIUserNotificationType { + UIUserNotificationTypeNone(0), + UIUserNotificationTypeBadge(1), + UIUserNotificationTypeSound(2), + UIUserNotificationTypeAlert(4); + + final int value; + const UIUserNotificationType(this.value); + + static UIUserNotificationType fromValue(int value) => switch (value) { + 0 => UIUserNotificationTypeNone, + 1 => UIUserNotificationTypeBadge, + 2 => UIUserNotificationTypeSound, + 4 => UIUserNotificationTypeAlert, + _ => throw ArgumentError( + "Unknown value for UIUserNotificationType: $value"), + }; +} + +late final _sel_settingsForTypes_categories_ = + objc.registerName("settingsForTypes:categories:"); +final _objc_msgSend_642 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_types = objc.registerName("types"); +final _objc_msgSend_643 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_categories = objc.registerName("categories"); +late final _sel_registerUserNotificationSettings_ = + objc.registerName("registerUserNotificationSettings:"); +final _objc_msgSend_644 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_currentUserNotificationSettings = + objc.registerName("currentUserNotificationSettings"); +final _objc_msgSend_645 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_beginReceivingRemoteControlEvents = + objc.registerName("beginReceivingRemoteControlEvents"); +late final _sel_endReceivingRemoteControlEvents = + objc.registerName("endReceivingRemoteControlEvents"); +late final _sel_setNewsstandIconImage_ = + objc.registerName("setNewsstandIconImage:"); +final _objc_msgSend_646 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_shortcutItems = objc.registerName("shortcutItems"); +late final _sel_setShortcutItems_ = objc.registerName("setShortcutItems:"); +late final _sel_supportsAlternateIcons = + objc.registerName("supportsAlternateIcons"); +void _ObjCBlock_ffiVoid_NSError1_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_NSError1_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_NSError1 extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSError1._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSError1 castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSError1._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSError1.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSError1_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSError1.fromFunction(void Function(objc.NSError?) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSError1_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0.address == 0 + ? null + : objc.NSError.castFromPointer(arg0, + retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSError1.listener(void Function(objc.NSError?) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSError1( + objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSError1_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn(arg0.address == 0 + ? null + : objc.NSError.castFromPointer(arg0, + retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(objc.NSError? arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function( + ffi.Pointer, ffi.Pointer)>()( + pointer, arg0?.pointer ?? ffi.nullptr); +} + +late final _sel_setAlternateIconName_completionHandler_ = + objc.registerName("setAlternateIconName:completionHandler:"); +final _objc_msgSend_647 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_alternateIconName = objc.registerName("alternateIconName"); +late final _sel_extendStateRestoration = + objc.registerName("extendStateRestoration"); +late final _sel_completeStateRestoration = + objc.registerName("completeStateRestoration"); +late final _sel_ignoreSnapshotOnNextApplicationLaunch = + objc.registerName("ignoreSnapshotOnNextApplicationLaunch"); +late final _sel_registerObjectForStateRestoration_restorationIdentifier_ = objc + .registerName("registerObjectForStateRestoration:restorationIdentifier:"); +final _objc_msgSend_648 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_isProximitySensingEnabled = + objc.registerName("isProximitySensingEnabled"); +late final _sel_setProximitySensingEnabled_ = + objc.registerName("setProximitySensingEnabled:"); +late final _sel_setStatusBarHidden_animated_ = + objc.registerName("setStatusBarHidden:animated:"); +final _objc_msgSend_649 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Bool, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, bool, bool)>(); +late final _sel_setStatusBarOrientation_ = + objc.registerName("setStatusBarOrientation:"); +final _objc_msgSend_650 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_setStatusBarOrientation_animated_ = + objc.registerName("setStatusBarOrientation:animated:"); +final _objc_msgSend_651 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int, bool)>(); +late final _sel_setStatusBarStyle_ = objc.registerName("setStatusBarStyle:"); +final _objc_msgSend_652 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_setStatusBarStyle_animated_ = + objc.registerName("setStatusBarStyle:animated:"); +final _objc_msgSend_653 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int, bool)>(); +late final _sel_setStatusBarHidden_ = objc.registerName("setStatusBarHidden:"); +late final _sel_setStatusBarHidden_withAnimation_ = + objc.registerName("setStatusBarHidden:withAnimation:"); +final _objc_msgSend_654 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Bool, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, bool, int)>(); +late final _sel_setKeepAliveTimeout_handler_ = + objc.registerName("setKeepAliveTimeout:handler:"); +final _objc_msgSend_655 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer)>(); +late final _sel_clearKeepAliveTimeout = + objc.registerName("clearKeepAliveTimeout"); + +/// ! @enum ASWebAuthenticationSessionErrorCode +/// @abstract Error code of the NSError object passed in by ASWebAuthenticationSessionCompletionHandler. +/// @constant ASWebAuthenticationSessionErrorCodeCanceledLogin The user has canceled login by cancelling the +/// alert asking for permission to log in to this app, or by dismissing the view controller for loading the +/// authentication webpage. +/// @constant ASWebAuthenticationSessionErrorCodePresentationContextNotProvided A valid presentationContextProvider +/// was not found when -start was called. Ensure this property was not nil when -start was called. +/// @constant ASWebAuthenticationSessionErrorCodePresentationContextInvalid The presentation context returned +/// was not elligible to show the authentication UI. For iOS, validate that the UIWindow is in a foreground scene. +enum ASWebAuthenticationSessionErrorCode { + ASWebAuthenticationSessionErrorCodeCanceledLogin(1), + ASWebAuthenticationSessionErrorCodePresentationContextNotProvided(2), + ASWebAuthenticationSessionErrorCodePresentationContextInvalid(3); + + final int value; + const ASWebAuthenticationSessionErrorCode(this.value); + + static ASWebAuthenticationSessionErrorCode fromValue(int value) => + switch (value) { + 1 => ASWebAuthenticationSessionErrorCodeCanceledLogin, + 2 => ASWebAuthenticationSessionErrorCodePresentationContextNotProvided, + 3 => ASWebAuthenticationSessionErrorCodePresentationContextInvalid, + _ => throw ArgumentError( + "Unknown value for ASWebAuthenticationSessionErrorCode: $value"), + }; +} + +/// ! +/// @class ASWebAuthenticationSession +/// An ASWebAuthenticationSession object can be used to authenticate a user with a web service, even if the web service is run +/// by a third party. ASWebAuthenticationSession puts the user in control of whether they want to use their existing logged-in +/// session from Safari. The app provides a URL that points to the authentication webpage. The page will be loaded in a secure +/// view controller. From the webpage, the user can authenticate herself and grant access to the app. +/// On completion, the service will send a callback URL with an authentication token, and this URL will be passed to the app by +/// ASWebAuthenticationSessionCompletionHandler. +/// +/// The callback URL usually has a custom URL scheme. For the app to receive the callback URL, it needs to either register the +/// custom URL scheme in its Info.plist, or set the scheme to callbackURLScheme argument in the initializer. +/// +/// If the user has already logged into the web service in Safari or other apps via ASWebAuthenticationSession, it is possible to +/// share the existing login information. An alert will be presented to get the user's consent for sharing their existing login +/// information. If the user cancels the alert, the session will be canceled, and the completion handler will be called with +/// the error code ASWebAuthenticationSessionErrorCodeCanceledLogin. +/// +/// If the user taps Cancel when showing the login webpage for the web service, the session will be canceled, and the completion +/// handler will be called with the error code ASWebAuthenticationSessionErrorCodeCanceledLogin. +/// +/// The app can cancel the session by calling -[ASWebAuthenticationSession cancel]. This will also dismiss the view controller that +/// is showing the web service's login page. +class ASWebAuthenticationSession extends objc.NSObject { + ASWebAuthenticationSession._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [ASWebAuthenticationSession] that points to the same underlying object as [other]. + ASWebAuthenticationSession.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [ASWebAuthenticationSession] that wraps the given raw object pointer. + ASWebAuthenticationSession.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [ASWebAuthenticationSession]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_ASWebAuthenticationSession); + } + + /// ! @abstract Returns an ASWebAuthenticationSession object. + /// @param URL the initial URL pointing to the authentication webpage. Only supports URLs with http:// or https:// schemes. + /// @param callbackURLScheme the custom URL scheme that the app expects in the callback URL. + /// @param completionHandler the completion handler which is called when the session is completed successfully or canceled by user. + ASWebAuthenticationSession initWithURL_callbackURLScheme_completionHandler_( + objc.NSURL URL, + objc.NSString? callbackURLScheme, + ObjCBlock_ffiVoid_NSURL_NSError completionHandler) { + final _ret = _objc_msgSend_656( + this.pointer, + _sel_initWithURL_callbackURLScheme_completionHandler_, + URL.pointer, + callbackURLScheme?.pointer ?? ffi.nullptr, + completionHandler.pointer); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithURL:callback:completionHandler: + ASWebAuthenticationSession initWithURL_callback_completionHandler_( + objc.NSURL URL, + ASWebAuthenticationSessionCallback callback, + ObjCBlock_ffiVoid_NSURL_NSError completionHandler) { + final _ret = _objc_msgSend_657( + this.pointer, + _sel_initWithURL_callback_completionHandler_, + URL.pointer, + callback.pointer, + completionHandler.pointer); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: true, release: true); + } + + /// ! @abstract Provides context to target where in an application's UI the authorization view should be shown. A provider + /// must be set prior to calling -start, otherwise the authorization view cannot be displayed. If deploying to iOS prior to + /// 13.0, the desired window is inferred by the application's key window. + objc.ObjCObjectBase? get presentationContextProvider { + final _ret = + _objc_msgSend_2(this.pointer, _sel_presentationContextProvider); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// ! @abstract Provides context to target where in an application's UI the authorization view should be shown. A provider + /// must be set prior to calling -start, otherwise the authorization view cannot be displayed. If deploying to iOS prior to + /// 13.0, the desired window is inferred by the application's key window. + set presentationContextProvider(objc.ObjCObjectBase? value) { + return _objc_msgSend_3(this.pointer, _sel_setPresentationContextProvider_, + value?.pointer ?? ffi.nullptr); + } + + /// ! @abstract Indicates whether this session should ask the browser for an ephemeral session. + /// @discussion Ephemeral web browser sessions do not not share cookies or other browsing data with a user's normal browser session. + /// This value is NO by default. Setting this property after calling -[ASWebAuthenticationSession start] has no effect. + bool get prefersEphemeralWebBrowserSession { + return _objc_msgSend_5( + this.pointer, _sel_prefersEphemeralWebBrowserSession); + } + + /// ! @abstract Indicates whether this session should ask the browser for an ephemeral session. + /// @discussion Ephemeral web browser sessions do not not share cookies or other browsing data with a user's normal browser session. + /// This value is NO by default. Setting this property after calling -[ASWebAuthenticationSession start] has no effect. + set prefersEphemeralWebBrowserSession(bool value) { + return _objc_msgSend_6( + this.pointer, _sel_setPrefersEphemeralWebBrowserSession_, value); + } + + /// Any additional header fields to be set when loading the initial URL. + /// All header field names must start with the "X-" prefix. + objc.NSDictionary? get additionalHeaderFields { + final _ret = _objc_msgSend_104(this.pointer, _sel_additionalHeaderFields); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// Any additional header fields to be set when loading the initial URL. + /// All header field names must start with the "X-" prefix. + set additionalHeaderFields(objc.NSDictionary? value) { + return _objc_msgSend_105(this.pointer, _sel_setAdditionalHeaderFields_, + value?.pointer ?? ffi.nullptr); + } + + /// ! @abstract Returns whether the session can be successfully started. This property returns the same value as calling -start, + /// but without the side effect of actually starting the session. + bool get canStart { + return _objc_msgSend_5(this.pointer, _sel_canStart); + } + + /// ! @abstract Starts the ASWebAuthenticationSession instance after it is instantiated. + /// @discussion start can only be called once for an ASWebAuthenticationSession instance. This also means calling start on a + /// canceled session will fail. + /// @result Returns YES if the session starts successfully. + bool start() { + return _objc_msgSend_5(this.pointer, _sel_start); + } + + /// ! @abstract Cancel an ASWebAuthenticationSession. If the view controller is already presented to load the webpage for + /// authentication, it will be dismissed. Calling cancel on an already canceled session will have no effect. + void cancel() { + _objc_msgSend_4(this.pointer, _sel_cancel); + } + + /// new + static ASWebAuthenticationSession new1() { + final _ret = _objc_msgSend_18(_class_ASWebAuthenticationSession, _sel_new); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: false, release: true); + } + + /// init + ASWebAuthenticationSession init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: true, release: true); + } + + /// allocWithZone: + static ASWebAuthenticationSession allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_ASWebAuthenticationSession, _sel_allocWithZone_, zone); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static ASWebAuthenticationSession alloc() { + final _ret = + _objc_msgSend_18(_class_ASWebAuthenticationSession, _sel_alloc); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_ASWebAuthenticationSession = + objc.getClass("ASWebAuthenticationSession"); +void _ObjCBlock_ffiVoid_NSURL_NSError_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +void _ObjCBlock_ffiVoid_NSURL_NSError_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as void Function(ffi.Pointer, + ffi.Pointer))(arg0, arg1); + +class ObjCBlock_ffiVoid_NSURL_NSError extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSURL_NSError._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSURL_NSError castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSURL_NSError._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSURL_NSError.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSURL_NSError_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSURL_NSError.fromFunction( + void Function(objc.NSURL?, objc.NSError?) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSURL_NSError_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0.address == 0 + ? null + : objc.NSURL.castFromPointer(arg0, retain: true, release: true), + arg1.address == 0 ? null : objc.NSError.castFromPointer(arg1, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSURL_NSError.listener( + void Function(objc.NSURL?, objc.NSError?) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSURL_NSError(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= + ffi.NativeCallable, ffi.Pointer, ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSURL_NSError_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0.address == 0 + ? null + : objc.NSURL + .castFromPointer(arg0, retain: false, release: true), + arg1.address == 0 + ? null + : objc.NSError.castFromPointer(arg1, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(objc.NSURL? arg0, objc.NSError? arg1) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0?.pointer ?? ffi.nullptr, arg1?.pointer ?? ffi.nullptr); +} + +late final _sel_initWithURL_callbackURLScheme_completionHandler_ = + objc.registerName("initWithURL:callbackURLScheme:completionHandler:"); +final _objc_msgSend_656 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// ASWebAuthenticationSessionCallback +class ASWebAuthenticationSessionCallback extends objc.NSObject { + ASWebAuthenticationSessionCallback._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [ASWebAuthenticationSessionCallback] that points to the same underlying object as [other]. + ASWebAuthenticationSessionCallback.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [ASWebAuthenticationSessionCallback] that wraps the given raw object pointer. + ASWebAuthenticationSessionCallback.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [ASWebAuthenticationSessionCallback]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, + _class_ASWebAuthenticationSessionCallback); + } + + /// Creates a callback object that matches against URLs with the given custom scheme. + /// @param customScheme The custom scheme that the app expects in the callback URL. + static ASWebAuthenticationSessionCallback callbackWithCustomScheme_( + objc.NSString customScheme) { + final _ret = _objc_msgSend_95(_class_ASWebAuthenticationSessionCallback, + _sel_callbackWithCustomScheme_, customScheme.pointer); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: true, release: true); + } + + /// Creates a callback object that matches against HTTPS URLs with the given host and path. + /// @param host The host that the app expects in the callback URL. The host must be associated with the + /// app using associated web credentials domains. + /// @param path The path that the app expects in the callback URL. + static ASWebAuthenticationSessionCallback callbackWithHTTPSHost_path_( + objc.NSString host, objc.NSString path) { + final _ret = _objc_msgSend_535(_class_ASWebAuthenticationSessionCallback, + _sel_callbackWithHTTPSHost_path_, host.pointer, path.pointer); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + ASWebAuthenticationSessionCallback init() { + final _ret = _objc_msgSend_18(this.pointer, _sel_init); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static ASWebAuthenticationSessionCallback new1() { + final _ret = + _objc_msgSend_18(_class_ASWebAuthenticationSessionCallback, _sel_new); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: false, release: true); + } + + /// Check whether a given main-frame navigation URL matches the callback expected by the client app. Handles all URL-based callback strategies, including custom schemes and HTTPS navigations. + /// This is mainly meant for web browsers adopting the ASWebAuthenticationWebBrowser API, but may also be useful for other apps for debugging purposes. + /// @param url The URL to check. + bool matchesURL_(objc.NSURL url) { + return _objc_msgSend_7(this.pointer, _sel_matchesURL_, url.pointer); + } + + /// allocWithZone: + static ASWebAuthenticationSessionCallback allocWithZone_( + ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_19( + _class_ASWebAuthenticationSessionCallback, _sel_allocWithZone_, zone); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static ASWebAuthenticationSessionCallback alloc() { + final _ret = + _objc_msgSend_18(_class_ASWebAuthenticationSessionCallback, _sel_alloc); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_ASWebAuthenticationSessionCallback = + objc.getClass("ASWebAuthenticationSessionCallback"); +late final _sel_callbackWithCustomScheme_ = + objc.registerName("callbackWithCustomScheme:"); +late final _sel_callbackWithHTTPSHost_path_ = + objc.registerName("callbackWithHTTPSHost:path:"); +late final _sel_matchesURL_ = objc.registerName("matchesURL:"); +late final _sel_initWithURL_callback_completionHandler_ = + objc.registerName("initWithURL:callback:completionHandler:"); +final _objc_msgSend_657 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_presentationContextProvider = + objc.registerName("presentationContextProvider"); +late final _sel_setPresentationContextProvider_ = + objc.registerName("setPresentationContextProvider:"); +late final _sel_prefersEphemeralWebBrowserSession = + objc.registerName("prefersEphemeralWebBrowserSession"); +late final _sel_setPrefersEphemeralWebBrowserSession_ = + objc.registerName("setPrefersEphemeralWebBrowserSession:"); +late final _sel_additionalHeaderFields = + objc.registerName("additionalHeaderFields"); +late final _sel_setAdditionalHeaderFields_ = + objc.registerName("setAdditionalHeaderFields:"); +late final _sel_canStart = objc.registerName("canStart"); +late final _sel_start = objc.registerName("start"); +late final _sel_cancel = objc.registerName("cancel"); + +/// ! @abstract Provides context to target where in an application's UI the authorization view should be shown. +abstract final class ASWebAuthenticationPresentationContextProviding { + /// Builds an object that implements the ASWebAuthenticationPresentationContextProviding protocol. To implement + /// multiple protocols, use [addToBuilder] or [objc.ObjCProtocolBuilder] directly. + static objc.ObjCObjectBase implement( + {required UIWindow Function(ASWebAuthenticationSession) + presentationAnchorForWebAuthenticationSession_}) { + final builder = objc.ObjCProtocolBuilder(); + ASWebAuthenticationPresentationContextProviding + .presentationAnchorForWebAuthenticationSession_ + .implement(builder, presentationAnchorForWebAuthenticationSession_); + return builder.build(); + } + + /// Adds the implementation of the ASWebAuthenticationPresentationContextProviding protocol to an existing + /// [objc.ObjCProtocolBuilder]. + static void addToBuilder(objc.ObjCProtocolBuilder builder, + {required UIWindow Function(ASWebAuthenticationSession) + presentationAnchorForWebAuthenticationSession_}) { + ASWebAuthenticationPresentationContextProviding + .presentationAnchorForWebAuthenticationSession_ + .implement(builder, presentationAnchorForWebAuthenticationSession_); + } + + /// ! @abstract Return the ASPresentationAnchor in the closest proximity to where a user interacted with your app to trigger + /// authentication. If starting an ASWebAuthenticationSession on first launch, use the application's main window. + /// @param session The session requesting a presentation anchor. + /// @result The ASPresentationAnchor most closely associated with the UI used to trigger authentication. + static final presentationAnchorForWebAuthenticationSession_ = + objc.ObjCProtocolMethod( + _sel_presentationAnchorForWebAuthenticationSession_, + objc.getProtocolMethodSignature( + _protocol_ASWebAuthenticationPresentationContextProviding, + _sel_presentationAnchorForWebAuthenticationSession_, + isRequired: true, + isInstanceMethod: true, + ), + (UIWindow Function(ASWebAuthenticationSession) func) => + ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession.fromFunction( + (ffi.Pointer _, ASWebAuthenticationSession arg1) => + func(arg1)), + ); +} + +late final _protocol_ASWebAuthenticationPresentationContextProviding = + objc.getProtocol("ASWebAuthenticationPresentationContextProviding"); + +/// NSObject +abstract final class NSObject { + /// Builds an object that implements the NSObject protocol. To implement + /// multiple protocols, use [addToBuilder] or [objc.ObjCProtocolBuilder] directly. + static objc.ObjCObjectBase implement( + {required bool Function(objc.ObjCObjectBase) isEqual_, + required objc.ObjCObjectBase Function() class1, + required objc.ObjCObjectBase Function() self, + required objc.ObjCObjectBase Function(ffi.Pointer) + performSelector_, + required objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + performSelector_withObject_, + required objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + performSelector_withObject_withObject_, + required bool Function() isProxy, + required bool Function(objc.ObjCObjectBase) isKindOfClass_, + required bool Function(objc.ObjCObjectBase) isMemberOfClass_, + required bool Function(objc.Protocol) conformsToProtocol_, + required bool Function(ffi.Pointer) + respondsToSelector_, + required objc.ObjCObjectBase Function() retain, + required void Function() release, + required objc.ObjCObjectBase Function() autorelease, + required int Function() retainCount, + required ffi.Pointer<_NSZone> Function() zone, + required int Function() hash, + required objc.ObjCObjectBase Function() superclass, + required objc.NSString Function() description, + objc.NSString Function()? debugDescription}) { + final builder = objc.ObjCProtocolBuilder(); + NSObject.isEqual_.implement(builder, isEqual_); + NSObject.class1.implement(builder, class1); + NSObject.self.implement(builder, self); + NSObject.performSelector_.implement(builder, performSelector_); + NSObject.performSelector_withObject_ + .implement(builder, performSelector_withObject_); + NSObject.performSelector_withObject_withObject_ + .implement(builder, performSelector_withObject_withObject_); + NSObject.isProxy.implement(builder, isProxy); + NSObject.isKindOfClass_.implement(builder, isKindOfClass_); + NSObject.isMemberOfClass_.implement(builder, isMemberOfClass_); + NSObject.conformsToProtocol_.implement(builder, conformsToProtocol_); + NSObject.respondsToSelector_.implement(builder, respondsToSelector_); + NSObject.retain.implement(builder, retain); + NSObject.release.implement(builder, release); + NSObject.autorelease.implement(builder, autorelease); + NSObject.retainCount.implement(builder, retainCount); + NSObject.zone.implement(builder, zone); + NSObject.hash.implement(builder, hash); + NSObject.superclass.implement(builder, superclass); + NSObject.description.implement(builder, description); + NSObject.debugDescription.implement(builder, debugDescription); + return builder.build(); + } + + /// Adds the implementation of the NSObject protocol to an existing + /// [objc.ObjCProtocolBuilder]. + static void addToBuilder(objc.ObjCProtocolBuilder builder, + {required bool Function(objc.ObjCObjectBase) isEqual_, + required objc.ObjCObjectBase Function() class1, + required objc.ObjCObjectBase Function() self, + required objc.ObjCObjectBase Function(ffi.Pointer) + performSelector_, + required objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + performSelector_withObject_, + required objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + performSelector_withObject_withObject_, + required bool Function() isProxy, + required bool Function(objc.ObjCObjectBase) isKindOfClass_, + required bool Function(objc.ObjCObjectBase) isMemberOfClass_, + required bool Function(objc.Protocol) conformsToProtocol_, + required bool Function(ffi.Pointer) + respondsToSelector_, + required objc.ObjCObjectBase Function() retain, + required void Function() release, + required objc.ObjCObjectBase Function() autorelease, + required int Function() retainCount, + required ffi.Pointer<_NSZone> Function() zone, + required int Function() hash, + required objc.ObjCObjectBase Function() superclass, + required objc.NSString Function() description, + objc.NSString Function()? debugDescription}) { + NSObject.isEqual_.implement(builder, isEqual_); + NSObject.class1.implement(builder, class1); + NSObject.self.implement(builder, self); + NSObject.performSelector_.implement(builder, performSelector_); + NSObject.performSelector_withObject_ + .implement(builder, performSelector_withObject_); + NSObject.performSelector_withObject_withObject_ + .implement(builder, performSelector_withObject_withObject_); + NSObject.isProxy.implement(builder, isProxy); + NSObject.isKindOfClass_.implement(builder, isKindOfClass_); + NSObject.isMemberOfClass_.implement(builder, isMemberOfClass_); + NSObject.conformsToProtocol_.implement(builder, conformsToProtocol_); + NSObject.respondsToSelector_.implement(builder, respondsToSelector_); + NSObject.retain.implement(builder, retain); + NSObject.release.implement(builder, release); + NSObject.autorelease.implement(builder, autorelease); + NSObject.retainCount.implement(builder, retainCount); + NSObject.zone.implement(builder, zone); + NSObject.hash.implement(builder, hash); + NSObject.superclass.implement(builder, superclass); + NSObject.description.implement(builder, description); + NSObject.debugDescription.implement(builder, debugDescription); + } + + /// Builds an object that implements the NSObject protocol. To implement + /// multiple protocols, use [addToBuilder] or [objc.ObjCProtocolBuilder] directly. All + /// methods that can be implemented as listeners will be. + static objc.ObjCObjectBase implementAsListener( + {required bool Function(objc.ObjCObjectBase) isEqual_, + required objc.ObjCObjectBase Function() class1, + required objc.ObjCObjectBase Function() self, + required objc.ObjCObjectBase Function(ffi.Pointer) + performSelector_, + required objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + performSelector_withObject_, + required objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + performSelector_withObject_withObject_, + required bool Function() isProxy, + required bool Function(objc.ObjCObjectBase) isKindOfClass_, + required bool Function(objc.ObjCObjectBase) isMemberOfClass_, + required bool Function(objc.Protocol) conformsToProtocol_, + required bool Function(ffi.Pointer) + respondsToSelector_, + required objc.ObjCObjectBase Function() retain, + required void Function() release, + required objc.ObjCObjectBase Function() autorelease, + required int Function() retainCount, + required ffi.Pointer<_NSZone> Function() zone, + required int Function() hash, + required objc.ObjCObjectBase Function() superclass, + required objc.NSString Function() description, + objc.NSString Function()? debugDescription}) { + final builder = objc.ObjCProtocolBuilder(); + NSObject.isEqual_.implement(builder, isEqual_); + NSObject.class1.implement(builder, class1); + NSObject.self.implement(builder, self); + NSObject.performSelector_.implement(builder, performSelector_); + NSObject.performSelector_withObject_ + .implement(builder, performSelector_withObject_); + NSObject.performSelector_withObject_withObject_ + .implement(builder, performSelector_withObject_withObject_); + NSObject.isProxy.implement(builder, isProxy); + NSObject.isKindOfClass_.implement(builder, isKindOfClass_); + NSObject.isMemberOfClass_.implement(builder, isMemberOfClass_); + NSObject.conformsToProtocol_.implement(builder, conformsToProtocol_); + NSObject.respondsToSelector_.implement(builder, respondsToSelector_); + NSObject.retain.implement(builder, retain); + NSObject.release.implementAsListener(builder, release); + NSObject.autorelease.implement(builder, autorelease); + NSObject.retainCount.implement(builder, retainCount); + NSObject.zone.implement(builder, zone); + NSObject.hash.implement(builder, hash); + NSObject.superclass.implement(builder, superclass); + NSObject.description.implement(builder, description); + NSObject.debugDescription.implement(builder, debugDescription); + return builder.build(); + } + + /// Adds the implementation of the NSObject protocol to an existing + /// [objc.ObjCProtocolBuilder]. All methods that can be implemented as listeners will + /// be. + static void addToBuilderAsListener(objc.ObjCProtocolBuilder builder, + {required bool Function(objc.ObjCObjectBase) isEqual_, + required objc.ObjCObjectBase Function() class1, + required objc.ObjCObjectBase Function() self, + required objc.ObjCObjectBase Function(ffi.Pointer) + performSelector_, + required objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + performSelector_withObject_, + required objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + performSelector_withObject_withObject_, + required bool Function() isProxy, + required bool Function(objc.ObjCObjectBase) isKindOfClass_, + required bool Function(objc.ObjCObjectBase) isMemberOfClass_, + required bool Function(objc.Protocol) conformsToProtocol_, + required bool Function(ffi.Pointer) + respondsToSelector_, + required objc.ObjCObjectBase Function() retain, + required void Function() release, + required objc.ObjCObjectBase Function() autorelease, + required int Function() retainCount, + required ffi.Pointer<_NSZone> Function() zone, + required int Function() hash, + required objc.ObjCObjectBase Function() superclass, + required objc.NSString Function() description, + objc.NSString Function()? debugDescription}) { + NSObject.isEqual_.implement(builder, isEqual_); + NSObject.class1.implement(builder, class1); + NSObject.self.implement(builder, self); + NSObject.performSelector_.implement(builder, performSelector_); + NSObject.performSelector_withObject_ + .implement(builder, performSelector_withObject_); + NSObject.performSelector_withObject_withObject_ + .implement(builder, performSelector_withObject_withObject_); + NSObject.isProxy.implement(builder, isProxy); + NSObject.isKindOfClass_.implement(builder, isKindOfClass_); + NSObject.isMemberOfClass_.implement(builder, isMemberOfClass_); + NSObject.conformsToProtocol_.implement(builder, conformsToProtocol_); + NSObject.respondsToSelector_.implement(builder, respondsToSelector_); + NSObject.retain.implement(builder, retain); + NSObject.release.implementAsListener(builder, release); + NSObject.autorelease.implement(builder, autorelease); + NSObject.retainCount.implement(builder, retainCount); + NSObject.zone.implement(builder, zone); + NSObject.hash.implement(builder, hash); + NSObject.superclass.implement(builder, superclass); + NSObject.description.implement(builder, description); + NSObject.debugDescription.implement(builder, debugDescription); + } + + /// isEqual: + static final isEqual_ = + objc.ObjCProtocolMethod( + _sel_isEqual_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_isEqual_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(objc.ObjCObjectBase) func) => + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunction( + (ffi.Pointer _, objc.ObjCObjectBase arg1) => func(arg1)), + ); + + /// class + static final class1 = objc.ObjCProtocolMethod( + _sel_class, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_class, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// self + static final self = objc.ObjCProtocolMethod( + _sel_self, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_self, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// performSelector: + static final performSelector_ = objc.ObjCProtocolMethod< + objc.ObjCObjectBase Function(ffi.Pointer)>( + _sel_performSelector_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_performSelector_, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function(ffi.Pointer) func) => + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector.fromFunction( + (ffi.Pointer _, ffi.Pointer arg1) => + func(arg1)), + ); + + /// performSelector:withObject: + static final performSelector_withObject_ = objc.ObjCProtocolMethod< + objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase)>( + _sel_performSelector_withObject_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_performSelector_withObject_, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + func) => + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject + .fromFunction((ffi.Pointer _, + ffi.Pointer arg1, + objc.ObjCObjectBase arg2) => + func(arg1, arg2)), + ); + + /// performSelector:withObject:withObject: + static final performSelector_withObject_withObject_ = objc.ObjCProtocolMethod< + objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase)>( + _sel_performSelector_withObject_withObject_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_performSelector_withObject_withObject_, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + func) => + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject + .fromFunction((ffi.Pointer _, + ffi.Pointer arg1, + objc.ObjCObjectBase arg2, + objc.ObjCObjectBase arg3) => + func(arg1, arg2, arg3)), + ); + + /// isProxy + static final isProxy = objc.ObjCProtocolMethod( + _sel_isProxy, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_isProxy, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function() func) => ObjCBlock_bool_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// isKindOfClass: + static final isKindOfClass_ = + objc.ObjCProtocolMethod( + _sel_isKindOfClass_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_isKindOfClass_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(objc.ObjCObjectBase) func) => + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunction( + (ffi.Pointer _, objc.ObjCObjectBase arg1) => func(arg1)), + ); + + /// isMemberOfClass: + static final isMemberOfClass_ = + objc.ObjCProtocolMethod( + _sel_isMemberOfClass_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_isMemberOfClass_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(objc.ObjCObjectBase) func) => + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunction( + (ffi.Pointer _, objc.ObjCObjectBase arg1) => func(arg1)), + ); + + /// conformsToProtocol: + static final conformsToProtocol_ = + objc.ObjCProtocolMethod( + _sel_conformsToProtocol_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_conformsToProtocol_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(objc.Protocol) func) => + ObjCBlock_bool_ffiVoid_Protocol.fromFunction( + (ffi.Pointer _, objc.Protocol arg1) => func(arg1)), + ); + + /// respondsToSelector: + static final respondsToSelector_ = + objc.ObjCProtocolMethod)>( + _sel_respondsToSelector_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_respondsToSelector_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(ffi.Pointer) func) => + ObjCBlock_bool_ffiVoid_objcObjCSelector.fromFunction( + (ffi.Pointer _, ffi.Pointer arg1) => + func(arg1)), + ); + + /// retain + static final retain = objc.ObjCProtocolMethod( + _sel_retain, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_retain, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// release + static final release = objc.ObjCProtocolListenableMethod( + _sel_release, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_release, + isRequired: true, + isInstanceMethod: true, + ), + (void Function() func) => ObjCBlock_ffiVoid_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + (void Function() func) => ObjCBlock_ffiVoid_ffiVoid.listener(( + ffi.Pointer _, + ) => + func()), + ); + + /// autorelease + static final autorelease = + objc.ObjCProtocolMethod( + _sel_autorelease, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_autorelease, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// retainCount + static final retainCount = objc.ObjCProtocolMethod( + _sel_retainCount, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_retainCount, + isRequired: true, + isInstanceMethod: true, + ), + (int Function() func) => ObjCBlock_ffiUnsignedLong_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// zone + static final zone = objc.ObjCProtocolMethod Function()>( + _sel_zone, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_zone, + isRequired: true, + isInstanceMethod: true, + ), + (ffi.Pointer<_NSZone> Function() func) => + ObjCBlock_NSZone_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// hash + static final hash = objc.ObjCProtocolMethod( + _sel_hash, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_hash, + isRequired: true, + isInstanceMethod: true, + ), + (int Function() func) => ObjCBlock_ffiUnsignedLong_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// superclass + static final superclass = + objc.ObjCProtocolMethod( + _sel_superclass, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_superclass, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// description + static final description = objc.ObjCProtocolMethod( + _sel_description, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_description, + isRequired: true, + isInstanceMethod: true, + ), + (objc.NSString Function() func) => ObjCBlock_NSString_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// debugDescription + static final debugDescription = + objc.ObjCProtocolMethod( + _sel_debugDescription, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_debugDescription, + isRequired: false, + isInstanceMethod: true, + ), + (objc.NSString Function() func) => ObjCBlock_NSString_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); +} + +late final _protocol_NSObject = objc.getProtocol("NSObject"); +late final _sel_isEqual_ = objc.registerName("isEqual:"); +bool _ObjCBlock_bool_ffiVoid_objcObjCObject_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +bool _ObjCBlock_bool_ffiVoid_objcObjCObject_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_bool_ffiVoid_objcObjCObject extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_objcObjCObject._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_objcObjCObject castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_objcObjCObject._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunctionPointer( + ffi + .Pointer< + ffi + .NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc + .newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCObject_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunction( + bool Function(ffi.Pointer, objc.ObjCObjectBase) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCObject_closureTrampoline, + false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0, objc.ObjCObjectBase(arg1, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, objc.ObjCObjectBase arg1) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1.pointer); +} + +late final _sel_class = objc.registerName("class"); +ffi.Pointer _ObjCBlock_objcObjCObject_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()(arg0); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer))(arg0); + +class ObjCBlock_objcObjCObject_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_objcObjCObject_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_objcObjCObject_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_objcObjCObject_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid.fromFunction( + objc.ObjCObjectBase Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.ObjCObjectBase call(ffi.Pointer arg0) => objc.ObjCObjectBase( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0), + retain: false, + release: true); +} + +late final _sel_self = objc.registerName("self"); +late final _sel_performSelector_ = objc.registerName("performSelector:"); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector + extends objc.ObjCBlockBase { + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector.fromFunction( + objc.ObjCObjectBase Function( + ffi.Pointer, ffi.Pointer) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => + fn(arg0, arg1).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.ObjCObjectBase call( + ffi.Pointer arg0, ffi.Pointer arg1) => + objc.ObjCObjectBase( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1), + retain: false, + release: true); +} + +late final _sel_performSelector_withObject_ = + objc.registerName("performSelector:withObject:"); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject + extends objc.ObjCBlockBase { + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject._( + pointer, + retain: retain, + release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject.fromFunction( + objc.ObjCObjectBase Function(ffi.Pointer, ffi.Pointer, objc.ObjCObjectBase) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, arg1, objc.ObjCObjectBase(arg2, retain: true, release: true)).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.ObjCObjectBase call(ffi.Pointer arg0, + ffi.Pointer arg1, objc.ObjCObjectBase arg2) => + objc.ObjCObjectBase( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1, arg2.pointer), + retain: false, + release: true); +} + +late final _sel_performSelector_withObject_withObject_ = + objc.registerName("performSelector:withObject:withObject:"); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2, arg3); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2, arg3); + +class ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject + extends objc.ObjCBlockBase { + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject + ._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject.fromFunction( + objc.ObjCObjectBase Function(ffi.Pointer, ffi.Pointer, objc.ObjCObjectBase, objc.ObjCObjectBase) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject_closureTrampoline) + .cast(), + (ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + fn(arg0, arg1, objc.ObjCObjectBase(arg2, retain: true, release: true), objc.ObjCObjectBase(arg3, retain: true, release: true)).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.ObjCObjectBase call( + ffi.Pointer arg0, + ffi.Pointer arg1, + objc.ObjCObjectBase arg2, + objc.ObjCObjectBase arg3) => + objc.ObjCObjectBase( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1, arg2.pointer, arg3.pointer), + retain: false, + release: true); +} + +late final _sel_isProxy = objc.registerName("isProxy"); +bool _ObjCBlock_bool_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction arg0)>>() + .asFunction)>()(arg0); +bool _ObjCBlock_bool_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as bool Function(ffi.Pointer))(arg0); + +class ObjCBlock_bool_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction arg0)>> + ptr) + : this._(objc + .newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_fnPtrTrampoline, false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid.fromFunction(bool Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_closureTrampoline, false) + .cast(), + (ffi.Pointer arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0); +} + +late final _sel_isMemberOfClass_ = objc.registerName("isMemberOfClass:"); +late final _sel_conformsToProtocol_ = objc.registerName("conformsToProtocol:"); +bool _ObjCBlock_bool_ffiVoid_Protocol_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +bool _ObjCBlock_bool_ffiVoid_Protocol_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_bool_ffiVoid_Protocol extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_Protocol._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_Protocol castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_Protocol._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_Protocol.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_Protocol_fnPtrTrampoline, false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_Protocol.fromFunction( + bool Function(ffi.Pointer, objc.Protocol) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_Protocol_closureTrampoline, false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0, + objc.Protocol.castFromPointer(arg1, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, objc.Protocol arg1) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1.pointer); +} + +late final _sel_respondsToSelector_ = objc.registerName("respondsToSelector:"); +bool _ObjCBlock_bool_ffiVoid_objcObjCSelector_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +bool _ObjCBlock_bool_ffiVoid_objcObjCSelector_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_bool_ffiVoid_objcObjCSelector extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_objcObjCSelector._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_objcObjCSelector castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_objcObjCSelector._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCSelector.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCSelector_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCSelector.fromFunction( + bool Function(ffi.Pointer, ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCSelector_closureTrampoline, + false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => + fn(arg0, arg1))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, ffi.Pointer arg1) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1); +} + +late final _sel_retain = objc.registerName("retain"); +late final _sel_release = objc.registerName("release"); +void _ObjCBlock_ffiVoid_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function(ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction arg0)>> + ptr) + : this._(objc + .newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid.fromFunction( + void Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid.listener(void Function(ffi.Pointer) fn) + : this._((objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn(arg0)))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(ffi.Pointer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0); +} + +late final _sel_autorelease = objc.registerName("autorelease"); +late final _sel_retainCount = objc.registerName("retainCount"); +int _ObjCBlock_ffiUnsignedLong_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +int _ObjCBlock_ffiUnsignedLong_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as int Function(ffi.Pointer))(arg0); + +class ObjCBlock_ffiUnsignedLong_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_ffiUnsignedLong_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiUnsignedLong_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiUnsignedLong_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiUnsignedLong_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiUnsignedLong_ffiVoid_fnPtrTrampoline, 0) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiUnsignedLong_ffiVoid.fromFunction( + int Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiUnsignedLong_ffiVoid_closureTrampoline, 0) + .cast(), + (ffi.Pointer arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + int call(ffi.Pointer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0); +} + +late final _sel_zone = objc.registerName("zone"); +ffi.Pointer<_NSZone> _ObjCBlock_NSZone_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer)>()(arg0); +ffi.Pointer<_NSZone> _ObjCBlock_NSZone_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer<_NSZone> Function( + ffi.Pointer))(arg0); + +class ObjCBlock_NSZone_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_NSZone_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSZone_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_NSZone_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSZone_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer arg0)>> + ptr) + : this._( + objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer<_NSZone> Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSZone_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSZone_ffiVoid.fromFunction( + ffi.Pointer<_NSZone> Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer<_NSZone> Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSZone_ffiVoid_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + ffi.Pointer<_NSZone> call(ffi.Pointer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0); +} + +late final _sel_hash = objc.registerName("hash"); +late final _sel_superclass = objc.registerName("superclass"); +late final _sel_description = objc.registerName("description"); +ffi.Pointer _ObjCBlock_NSString_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()(arg0); +ffi.Pointer _ObjCBlock_NSString_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer))(arg0); + +class ObjCBlock_NSString_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_NSString_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSString_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_NSString_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSString_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSString_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSString_ffiVoid.fromFunction( + objc.NSString Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSString_ffiVoid_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.NSString call(ffi.Pointer arg0) => + objc.NSString.castFromPointer( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>()(pointer, arg0), + retain: false, + release: true); +} + +late final _sel_debugDescription = objc.registerName("debugDescription"); +late final _sel_presentationAnchorForWebAuthenticationSession_ = + objc.registerName("presentationAnchorForWebAuthenticationSession:"); +ffi.Pointer + _ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +ffi.Pointer + _ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession + extends objc.ObjCBlockBase { + ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession.fromFunction( + UIWindow Function(ffi.Pointer, ASWebAuthenticationSession) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_UIWindow_ffiVoid_ASWebAuthenticationSession_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0, + ASWebAuthenticationSession.castFromPointer(arg1, retain: true, release: true)) + .retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + UIWindow call(ffi.Pointer arg0, ASWebAuthenticationSession arg1) => + UIWindow.castFromPointer( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer), + retain: false, + release: true); +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/native/macos/authentication_services.ffi.dart b/packages/native/auth/native_auth_flutter/lib/src/native/macos/authentication_services.ffi.dart new file mode 100644 index 0000000..cd08f48 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/native/macos/authentication_services.ffi.dart @@ -0,0 +1,25085 @@ +// ignore_for_file: type=lint +// ignore_for_file: return_of_invalid_type + +// AUTO GENERATED FILE, DO NOT EDIT. +// +// Generated by `package:ffigen`. +import 'dart:ffi' as ffi; +import 'package:objective_c/objective_c.dart' as objc; + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSEvent( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSError( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSEvent_bool( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSWindow_bool( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSTimer( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSArray( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSNotification( + ffi.Pointer block, +); + +@ffi.Native Function(ffi.Pointer)>( + isLeaf: true) +external ffi.Pointer + wrapListenerBlock_ObjCBlock_ffiVoid_NSURL_NSError( + ffi.Pointer block, +); + +/// NSApplication +class NSApplication extends NSResponder { + NSApplication._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSApplication] that points to the same underlying object as [other]. + NSApplication.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSApplication] that wraps the given raw object pointer. + NSApplication.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSApplication]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSApplication); + } + + /// sharedApplication + static NSApplication getSharedApplication() { + final _ret = _objc_msgSend_1(_class_NSApplication, _sel_sharedApplication); + return NSApplication.castFromPointer(_ret, retain: true, release: true); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// hide: + void hide_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_hide_, sender?.pointer ?? ffi.nullptr); + } + + /// unhide: + void unhide_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_unhide_, sender?.pointer ?? ffi.nullptr); + } + + /// unhideWithoutActivation + void unhideWithoutActivation() { + _objc_msgSend_5(this.pointer, _sel_unhideWithoutActivation); + } + + /// windowWithWindowNumber: + NSWindow? windowWithWindowNumber_(int windowNum) { + final _ret = _objc_msgSend_286( + this.pointer, _sel_windowWithWindowNumber_, windowNum); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// mainWindow + NSWindow? get mainWindow { + final _ret = _objc_msgSend_32(this.pointer, _sel_mainWindow); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// keyWindow + NSWindow? get keyWindow { + final _ret = _objc_msgSend_32(this.pointer, _sel_keyWindow); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// isActive + bool get active { + return _objc_msgSend_17(this.pointer, _sel_isActive); + } + + /// isHidden + bool get hidden { + return _objc_msgSend_17(this.pointer, _sel_isHidden); + } + + /// isRunning + bool get running { + return _objc_msgSend_17(this.pointer, _sel_isRunning); + } + + /// deactivate + void deactivate() { + _objc_msgSend_5(this.pointer, _sel_deactivate); + } + + /// Makes the receiver the active app. + void activateIgnoringOtherApps_(bool flag) { + _objc_msgSend_144(this.pointer, _sel_activateIgnoringOtherApps_, flag); + } + + /// Makes the receiver the active app, if possible. + /// + /// You shouldn’t assume the app will be active immediately + /// after sending this message. The framework also does not + /// guarantee that the app will be activated at all. + /// + /// For cooperative activation, the other application should + /// call `-yieldActivationToApplication:` or equivalent prior + /// to the target application invoking `-activate`. + /// + /// Invoking `-activate` on an already-active application + /// cancels any pending activation yields by the receiver. + void activate() { + _objc_msgSend_5(this.pointer, _sel_activate); + } + + /// Explicitly allows another application to make itself active. + /// + /// Calling this method will not deactivate the current app, nor + /// will it activate the other app. For cooperative or coordinated + /// activation, the other app should request to be activated at + /// some point in the future by calling `activate` or equivalent. + void yieldActivationToApplication_(NSRunningApplication application) { + _objc_msgSend_294( + this.pointer, _sel_yieldActivationToApplication_, application.pointer); + } + + /// Same as `-yieldActivationToApplication:`, but the provided + /// bundle identifier does not have to correspond to a currently + /// running application. + /// + /// This method should be used to yield activation to apps that + /// may not be running at the time of invoking it. If it is known + /// that the target application is currently running, use + /// `-yieldActivationToApplication:` instead. + void yieldActivationToApplicationWithBundleIdentifier_( + objc.NSString bundleIdentifier) { + _objc_msgSend_29( + this.pointer, + _sel_yieldActivationToApplicationWithBundleIdentifier_, + bundleIdentifier.pointer); + } + + /// hideOtherApplications: + void hideOtherApplications_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_hideOtherApplications_, + sender?.pointer ?? ffi.nullptr); + } + + /// unhideAllApplications: + void unhideAllApplications_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_unhideAllApplications_, + sender?.pointer ?? ffi.nullptr); + } + + /// finishLaunching + void finishLaunching() { + _objc_msgSend_5(this.pointer, _sel_finishLaunching); + } + + /// run + void run() { + _objc_msgSend_5(this.pointer, _sel_run); + } + + /// runModalForWindow: + int runModalForWindow_(NSWindow window) { + return _objc_msgSend_295( + this.pointer, _sel_runModalForWindow_, window.pointer); + } + + /// stop: + void stop_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_stop_, sender?.pointer ?? ffi.nullptr); + } + + /// stopModal + void stopModal() { + _objc_msgSend_5(this.pointer, _sel_stopModal); + } + + /// stopModalWithCode: + void stopModalWithCode_(int returnCode) { + _objc_msgSend_26(this.pointer, _sel_stopModalWithCode_, returnCode); + } + + /// abortModal + void abortModal() { + _objc_msgSend_5(this.pointer, _sel_abortModal); + } + + /// modalWindow + NSWindow? get modalWindow { + final _ret = _objc_msgSend_32(this.pointer, _sel_modalWindow); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// beginModalSessionForWindow: + ffi.Pointer<_NSModalSession> beginModalSessionForWindow_(NSWindow window) { + return _objc_msgSend_296( + this.pointer, _sel_beginModalSessionForWindow_, window.pointer); + } + + /// runModalSession: + int runModalSession_(ffi.Pointer<_NSModalSession> session) { + return _objc_msgSend_297(this.pointer, _sel_runModalSession_, session); + } + + /// endModalSession: + void endModalSession_(ffi.Pointer<_NSModalSession> session) { + _objc_msgSend_298(this.pointer, _sel_endModalSession_, session); + } + + /// terminate: + void terminate_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_terminate_, sender?.pointer ?? ffi.nullptr); + } + + /// Inform the user that this application needs attention - call this method only if your application is not already active. + int requestUserAttention_(NSRequestUserAttentionType requestType) { + return _objc_msgSend_299( + this.pointer, _sel_requestUserAttention_, requestType.value); + } + + /// cancelUserAttentionRequest: + void cancelUserAttentionRequest_(int request) { + _objc_msgSend_26(this.pointer, _sel_cancelUserAttentionRequest_, request); + } + + /// Execute a block for each of the app's windows. Set `*stop = YES` if desired, to halt the enumeration early. + void enumerateWindowsWithOptions_usingBlock_( + NSWindowListOptions options, ObjCBlock_ffiVoid_NSWindow_bool block) { + _objc_msgSend_300( + this.pointer, + _sel_enumerateWindowsWithOptions_usingBlock_, + options.value, + block.pointer); + } + + /// preventWindowOrdering + void preventWindowOrdering() { + _objc_msgSend_5(this.pointer, _sel_preventWindowOrdering); + } + + /// windows + objc.ObjCObjectBase get windows { + final _ret = _objc_msgSend_34(this.pointer, _sel_windows); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setWindowsNeedUpdate: + void setWindowsNeedUpdate_(bool needUpdate) { + _objc_msgSend_144(this.pointer, _sel_setWindowsNeedUpdate_, needUpdate); + } + + /// updateWindows + void updateWindows() { + _objc_msgSend_5(this.pointer, _sel_updateWindows); + } + + /// mainMenu + NSMenu? get mainMenu { + final _ret = _objc_msgSend_125(this.pointer, _sel_mainMenu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// setMainMenu: + set mainMenu(NSMenu? value) { + return _objc_msgSend_126( + this.pointer, _sel_setMainMenu_, value?.pointer ?? ffi.nullptr); + } + + /// Set or get the Help menu for the app. If a non-nil menu is set as the Help menu, Spotlight for Help will be installed in it; otherwise AppKit will install Spotlight for Help into a menu of its choosing (and that menu is not returned from `-helpMenu`). If you wish to completely suppress Spotlight for Help, you can set a menu that does not appear in the menu bar. @c NSApplication retains its Help menu and releases it when a different menu is set. + NSMenu? get helpMenu { + final _ret = _objc_msgSend_125(this.pointer, _sel_helpMenu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// Set or get the Help menu for the app. If a non-nil menu is set as the Help menu, Spotlight for Help will be installed in it; otherwise AppKit will install Spotlight for Help into a menu of its choosing (and that menu is not returned from `-helpMenu`). If you wish to completely suppress Spotlight for Help, you can set a menu that does not appear in the menu bar. @c NSApplication retains its Help menu and releases it when a different menu is set. + set helpMenu(NSMenu? value) { + return _objc_msgSend_126( + this.pointer, _sel_setHelpMenu_, value?.pointer ?? ffi.nullptr); + } + + /// applicationIconImage + NSImage get applicationIconImage { + final _ret = _objc_msgSend_135(this.pointer, _sel_applicationIconImage); + return NSImage.castFromPointer(_ret, retain: true, release: true); + } + + /// setApplicationIconImage: + set applicationIconImage(NSImage value) { + return _objc_msgSend_136( + this.pointer, _sel_setApplicationIconImage_, value.pointer); + } + + /// @return The activation policy of the application. + NSApplicationActivationPolicy activationPolicy() { + final _ret = _objc_msgSend_287(this.pointer, _sel_activationPolicy); + return NSApplicationActivationPolicy.fromValue(_ret); + } + + /// Attempts to modify the application's activation policy. In OS X 10.9, any policy may be set; prior to 10.9, the activation policy may be changed to @c NSApplicationActivationPolicyProhibited or @c NSApplicationActivationPolicyRegular, but may not be changed to @c NSApplicationActivationPolicyAccessory. This returns @c YES if setting the activation policy is successful, and @c NO if not. + bool setActivationPolicy_(NSApplicationActivationPolicy activationPolicy) { + return _objc_msgSend_301( + this.pointer, _sel_setActivationPolicy_, activationPolicy.value); + } + + /// dockTile + NSDockTile get dockTile { + final _ret = _objc_msgSend_211(this.pointer, _sel_dockTile); + return NSDockTile.castFromPointer(_ret, retain: true, release: true); + } + + /// reportException: + void reportException_(NSException exception) { + _objc_msgSend_305(this.pointer, _sel_reportException_, exception.pointer); + } + + /// detachDrawingThread:toTarget:withObject: + static void detachDrawingThread_toTarget_withObject_( + ffi.Pointer selector, + objc.ObjCObjectBase target, + objc.ObjCObjectBase? argument) { + _objc_msgSend_306( + _class_NSApplication, + _sel_detachDrawingThread_toTarget_withObject_, + selector, + target.pointer, + argument?.pointer ?? ffi.nullptr); + } + + /// If an application delegate returns NSTerminateLater from -applicationShouldTerminate:, -replyToApplicationShouldTerminate: must be called with YES or NO once the application decides if it can terminate. + void replyToApplicationShouldTerminate_(bool shouldTerminate) { + _objc_msgSend_144( + this.pointer, _sel_replyToApplicationShouldTerminate_, shouldTerminate); + } + + /// If an application delegate encounters an error while handling `-application:openFiles:` or` -application:printFiles:`, `-replyToOpenOrPrint:` should be called with @c NSApplicationDelegateReplyFailure. If the user cancels the operation, @c NSApplicationDelegateReplyCancel should be used, and if the operation succeeds, @c NSApplicationDelegateReplySuccess should be used . + void replyToOpenOrPrint_(NSApplicationDelegateReply reply) { + _objc_msgSend_307(this.pointer, _sel_replyToOpenOrPrint_, reply.value); + } + + /// Opens the character palette. + void orderFrontCharacterPalette_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_orderFrontCharacterPalette_, + sender?.pointer ?? ffi.nullptr); + } + + /// Gets or sets the @c presentationOptions that should be in effect for the system when this application is the active application. Only certain combinations of @c NSApplicationPresentationOptions flags are allowed, as detailed in the AppKit Release Notes and the reference documentation for `-setPresentationOptions:`. When given an invalid combination of option flags, `-setPresentationOptions:` raises an exception. + NSApplicationPresentationOptions get presentationOptions { + final _ret = _objc_msgSend_308(this.pointer, _sel_presentationOptions); + return NSApplicationPresentationOptions.fromValue(_ret); + } + + /// Gets or sets the @c presentationOptions that should be in effect for the system when this application is the active application. Only certain combinations of @c NSApplicationPresentationOptions flags are allowed, as detailed in the AppKit Release Notes and the reference documentation for `-setPresentationOptions:`. When given an invalid combination of option flags, `-setPresentationOptions:` raises an exception. + set presentationOptions(NSApplicationPresentationOptions value) { + return _objc_msgSend_309( + this.pointer, _sel_setPresentationOptions_, value.value); + } + + /// @return The set of application presentation options that are currently in effect for the system. + /// These are the presentation options that have been put into effect by the currently active application. + NSApplicationPresentationOptions get currentSystemPresentationOptions { + final _ret = + _objc_msgSend_308(this.pointer, _sel_currentSystemPresentationOptions); + return NSApplicationPresentationOptions.fromValue(_ret); + } + + /// occlusionState + NSApplicationOcclusionState get occlusionState { + final _ret = _objc_msgSend_310(this.pointer, _sel_occlusionState); + return NSApplicationOcclusionState.fromValue(_ret); + } + + /// isProtectedDataAvailable + bool get protectedDataAvailable { + return _objc_msgSend_17(this.pointer, _sel_isProtectedDataAvailable); + } + + /// appearance + NSAppearance? get appearance { + final _ret = _objc_msgSend_339(this.pointer, _sel_appearance); + return _ret.address == 0 + ? null + : NSAppearance.castFromPointer(_ret, retain: true, release: true); + } + + /// setAppearance: + set appearance(NSAppearance? value) { + return _objc_msgSend_340( + this.pointer, _sel_setAppearance_, value?.pointer ?? ffi.nullptr); + } + + /// effectiveAppearance + NSAppearance get effectiveAppearance { + final _ret = _objc_msgSend_311(this.pointer, _sel_effectiveAppearance); + return NSAppearance.castFromPointer(_ret, retain: true, release: true); + } + + /// sendEvent: + void sendEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_sendEvent_, event.pointer); + } + + /// postEvent:atStart: + void postEvent_atStart_(NSEvent event, bool flag) { + _objc_msgSend_262( + this.pointer, _sel_postEvent_atStart_, event.pointer, flag); + } + + /// currentEvent + NSEvent? get currentEvent { + final _ret = _objc_msgSend_263(this.pointer, _sel_currentEvent); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// nextEventMatchingMask:untilDate:inMode:dequeue: + NSEvent? nextEventMatchingMask_untilDate_inMode_dequeue_(NSEventMask mask, + objc.NSDate? expiration, objc.NSString mode, bool deqFlag) { + final _ret = _objc_msgSend_260( + this.pointer, + _sel_nextEventMatchingMask_untilDate_inMode_dequeue_, + mask.value, + expiration?.pointer ?? ffi.nullptr, + mode.pointer, + deqFlag); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// discardEventsMatchingMask:beforeEvent: + void discardEventsMatchingMask_beforeEvent_( + NSEventMask mask, NSEvent? lastEvent) { + _objc_msgSend_261(this.pointer, _sel_discardEventsMatchingMask_beforeEvent_, + mask.value, lastEvent?.pointer ?? ffi.nullptr); + } + + /// sendAction:to:from: + bool sendAction_to_from_(ffi.Pointer action, + objc.ObjCObjectBase? target, objc.ObjCObjectBase? sender) { + return _objc_msgSend_341(this.pointer, _sel_sendAction_to_from_, action, + target?.pointer ?? ffi.nullptr, sender?.pointer ?? ffi.nullptr); + } + + /// targetForAction: + objc.ObjCObjectBase? targetForAction_(ffi.Pointer action) { + final _ret = _objc_msgSend_342(this.pointer, _sel_targetForAction_, action); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// targetForAction:to:from: + objc.ObjCObjectBase? targetForAction_to_from_( + ffi.Pointer action, + objc.ObjCObjectBase? target, + objc.ObjCObjectBase? sender) { + final _ret = _objc_msgSend_343(this.pointer, _sel_targetForAction_to_from_, + action, target?.pointer ?? ffi.nullptr, sender?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// tryToPerform:with: + bool tryToPerform_with_( + ffi.Pointer action, objc.ObjCObjectBase? object) { + return _objc_msgSend_171(this.pointer, _sel_tryToPerform_with_, action, + object?.pointer ?? ffi.nullptr); + } + + /// validRequestorForSendType:returnType: + objc.ObjCObjectBase? validRequestorForSendType_returnType_( + objc.NSString? sendType, objc.NSString? returnType) { + final _ret = _objc_msgSend_172( + this.pointer, + _sel_validRequestorForSendType_returnType_, + sendType?.pointer ?? ffi.nullptr, + returnType?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// windowsMenu + NSMenu? get windowsMenu { + final _ret = _objc_msgSend_125(this.pointer, _sel_windowsMenu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// setWindowsMenu: + set windowsMenu(NSMenu? value) { + return _objc_msgSend_126( + this.pointer, _sel_setWindowsMenu_, value?.pointer ?? ffi.nullptr); + } + + /// arrangeInFront: + void arrangeInFront_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_arrangeInFront_, sender?.pointer ?? ffi.nullptr); + } + + /// removeWindowsItem: + void removeWindowsItem_(NSWindow win) { + _objc_msgSend_227(this.pointer, _sel_removeWindowsItem_, win.pointer); + } + + /// addWindowsItem:title:filename: + void addWindowsItem_title_filename_( + NSWindow win, objc.NSString string, bool isFilename) { + _objc_msgSend_344(this.pointer, _sel_addWindowsItem_title_filename_, + win.pointer, string.pointer, isFilename); + } + + /// changeWindowsItem:title:filename: + void changeWindowsItem_title_filename_( + NSWindow win, objc.NSString string, bool isFilename) { + _objc_msgSend_344(this.pointer, _sel_changeWindowsItem_title_filename_, + win.pointer, string.pointer, isFilename); + } + + /// updateWindowsItem: + void updateWindowsItem_(NSWindow win) { + _objc_msgSend_227(this.pointer, _sel_updateWindowsItem_, win.pointer); + } + + /// miniaturizeAll: + void miniaturizeAll_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_miniaturizeAll_, sender?.pointer ?? ffi.nullptr); + } + + /// Use this method to get the status of Full Keyboard Access, as configured in the Keyboard preference pane. You may use this status to implement your own key loop or to implement in-control tabbing behavior similar to @c NSTableView. Because of the nature of the preference storage, you will not be notified of changes to the key if you attempt to observe it via key-value observing; however, calling this method is fairly inexpensive, so you should always call it when you need the underlying value instead of caching it. + bool get fullKeyboardAccessEnabled { + return _objc_msgSend_17(this.pointer, _sel_isFullKeyboardAccessEnabled); + } + + /// servicesMenu + NSMenu? get servicesMenu { + final _ret = _objc_msgSend_125(this.pointer, _sel_servicesMenu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// setServicesMenu: + set servicesMenu(NSMenu? value) { + return _objc_msgSend_126( + this.pointer, _sel_setServicesMenu_, value?.pointer ?? ffi.nullptr); + } + + /// registerServicesMenuSendTypes:returnTypes: + void registerServicesMenuSendTypes_returnTypes_( + objc.NSArray sendTypes, objc.NSArray returnTypes) { + _objc_msgSend_345( + this.pointer, + _sel_registerServicesMenuSendTypes_returnTypes_, + sendTypes.pointer, + returnTypes.pointer); + } + + /// servicesProvider + objc.ObjCObjectBase? get servicesProvider { + final _ret = _objc_msgSend_2(this.pointer, _sel_servicesProvider); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setServicesProvider: + set servicesProvider(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setServicesProvider_, value?.pointer ?? ffi.nullptr); + } + + /// orderFrontStandardAboutPanel: + void orderFrontStandardAboutPanel_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_orderFrontStandardAboutPanel_, + sender?.pointer ?? ffi.nullptr); + } + + /// orderFrontStandardAboutPanelWithOptions: + void orderFrontStandardAboutPanelWithOptions_( + objc.NSDictionary optionsDictionary) { + _objc_msgSend_346( + this.pointer, + _sel_orderFrontStandardAboutPanelWithOptions_, + optionsDictionary.pointer); + } + + /// Returns the application-wide user interface layout direction. + NSUserInterfaceLayoutDirection get userInterfaceLayoutDirection { + final _ret = + _objc_msgSend_160(this.pointer, _sel_userInterfaceLayoutDirection); + return NSUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// Disable or reenable relaunching this app on login, if the app was running at the time the user logged out. These methods increment and decrement a counter respectively; if the counter is 0 at the time the user logs out, then the app may be relaunched when the user logs back in. The counter is initially zero, so by default apps are relaunched. + /// + /// If your app should not be relaunched because it launches via some other mechanism (e.g. launchd), then the recommended usage is to call `-[NSApp disableRelaunchOnLogin]` once, and never pair it with an -enable call. + /// + /// If your app should not be relaunched because it triggers a restart (e.g. an installer), then the recommended usage is to call `-[NSApp disableRelaunchOnLogin]` immediately before you attempt to trigger a restart, and `-[NSApp enableRelaunchOnLogin]` immediately after. This is because the user may cancel restarting; if the user later restarts for another reason, then your app should be brought back. + /// + /// These methods are thread safe. + void disableRelaunchOnLogin() { + _objc_msgSend_5(this.pointer, _sel_disableRelaunchOnLogin); + } + + /// enableRelaunchOnLogin + void enableRelaunchOnLogin() { + _objc_msgSend_5(this.pointer, _sel_enableRelaunchOnLogin); + } + + /// registerForRemoteNotifications + void registerForRemoteNotifications() { + _objc_msgSend_5(this.pointer, _sel_registerForRemoteNotifications); + } + + /// unregisterForRemoteNotifications + void unregisterForRemoteNotifications() { + _objc_msgSend_5(this.pointer, _sel_unregisterForRemoteNotifications); + } + + /// @return @c YES if the application is currently registered for remote notifications, taking into account any systemwide settings; doesn't relate to connectivity. + bool get registeredForRemoteNotifications { + return _objc_msgSend_17( + this.pointer, _sel_isRegisteredForRemoteNotifications); + } + + /// The following are soft deprecated. + /// Please use the `-registerForRemoteNotifications` above and `-requestAuthorizationWithOptions:` from `UserNotifications.framework`. + void registerForRemoteNotificationTypes_(NSRemoteNotificationType types) { + _objc_msgSend_347( + this.pointer, _sel_registerForRemoteNotificationTypes_, types.value); + } + + /// enabledRemoteNotificationTypes + NSRemoteNotificationType get enabledRemoteNotificationTypes { + final _ret = + _objc_msgSend_348(this.pointer, _sel_enabledRemoteNotificationTypes); + return NSRemoteNotificationType.fromValue(_ret); + } + + /// `-runModalForWindow:relativeToWindow:` was deprecated in Mac OS X 10.0. Please use `-[NSWindow beginSheet:completionHandler:]` instead. + int runModalForWindow_relativeToWindow_(NSWindow window, NSWindow docWindow) { + return _objc_msgSend_349( + this.pointer, + _sel_runModalForWindow_relativeToWindow_, + window.pointer, + docWindow.pointer); + } + + /// `-beginModalSessionForWindow:relativeToWindow:` was deprecated in Mac OS X 10.0. Please use `-[NSWindow beginSheet:completionHandler:]` instead. + ffi.Pointer<_NSModalSession> beginModalSessionForWindow_relativeToWindow_( + NSWindow window, NSWindow docWindow) { + return _objc_msgSend_350( + this.pointer, + _sel_beginModalSessionForWindow_relativeToWindow_, + window.pointer, + docWindow.pointer); + } + + /// `-application:printFiles:` was deprecated in Mac OS X 10.4. + /// Implement `-application:printFiles:withSettings:showPrintPanels:` in your application delegate instead. + void application_printFiles_(NSApplication sender, objc.NSArray filenames) { + _objc_msgSend_351(this.pointer, _sel_application_printFiles_, + sender.pointer, filenames.pointer); + } + + /// `NSWindow`'s `-beginSheet:completionHandler:` and `-endSheet:returnCode:` should be used instead. `NSApplication`'s `-beginSheet:modalForWindow:modalDelegate:didEndSelector:contextInfo:` will continue to work as it previously did, leaking contextInfo and failing when there is already an existing sheet. + void beginSheet_modalForWindow_modalDelegate_didEndSelector_contextInfo_( + NSWindow sheet, + NSWindow docWindow, + objc.ObjCObjectBase? modalDelegate, + ffi.Pointer didEndSelector, + ffi.Pointer contextInfo) { + _objc_msgSend_352( + this.pointer, + _sel_beginSheet_modalForWindow_modalDelegate_didEndSelector_contextInfo_, + sheet.pointer, + docWindow.pointer, + modalDelegate?.pointer ?? ffi.nullptr, + didEndSelector, + contextInfo); + } + + /// endSheet: + void endSheet_(NSWindow sheet) { + _objc_msgSend_227(this.pointer, _sel_endSheet_, sheet.pointer); + } + + /// endSheet:returnCode: + void endSheet_returnCode_(NSWindow sheet, int returnCode) { + _objc_msgSend_228( + this.pointer, _sel_endSheet_returnCode_, sheet.pointer, returnCode); + } + + /// makeWindowsPerform:inOrder: + NSWindow? makeWindowsPerform_inOrder_( + ffi.Pointer selector, bool flag) { + final _ret = _objc_msgSend_353( + this.pointer, _sel_makeWindowsPerform_inOrder_, selector, flag); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// This method is deprecated as of macOS 10.12. Beginning in OS X 10.11 it would always return nil. Prior to this it would return an undefined graphics context that was not generally suitable for drawing. + NSGraphicsContext? get context { + final _ret = _objc_msgSend_68(this.pointer, _sel_context); + return _ret.address == 0 + ? null + : NSGraphicsContext.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSApplication init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSApplication.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + NSApplication? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_31(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : NSApplication.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSApplication new1() { + final _ret = _objc_msgSend_34(_class_NSApplication, _sel_new); + return NSApplication.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSApplication allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSApplication, _sel_allocWithZone_, zone); + return NSApplication.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSApplication alloc() { + final _ret = _objc_msgSend_34(_class_NSApplication, _sel_alloc); + return NSApplication.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSApplication = objc.getClass("NSApplication"); +late final _sel_sharedApplication = objc.registerName("sharedApplication"); +final _objc_msgSend_1 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_delegate = objc.registerName("delegate"); +final _objc_msgSend_2 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setDelegate_ = objc.registerName("setDelegate:"); +final _objc_msgSend_3 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_hide_ = objc.registerName("hide:"); +final _objc_msgSend_4 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_unhide_ = objc.registerName("unhide:"); +late final _sel_unhideWithoutActivation = + objc.registerName("unhideWithoutActivation"); +final _objc_msgSend_5 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSWindow +class NSWindow extends NSResponder { + NSWindow._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSWindow] that points to the same underlying object as [other]. + NSWindow.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSWindow] that wraps the given raw object pointer. + NSWindow.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSWindow]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSWindow); + } + + /// frameRectForContentRect:styleMask: + static void frameRectForContentRect_styleMask_( + ffi.Pointer stret, CGRect cRect, NSWindowStyleMask style) { + objc.useMsgSendVariants + ? _objc_msgSend_6Stret(stret, _class_NSWindow, + _sel_frameRectForContentRect_styleMask_, cRect, style.value) + : stret.ref = _objc_msgSend_6(_class_NSWindow, + _sel_frameRectForContentRect_styleMask_, cRect, style.value); + } + + /// contentRectForFrameRect:styleMask: + static void contentRectForFrameRect_styleMask_( + ffi.Pointer stret, CGRect fRect, NSWindowStyleMask style) { + objc.useMsgSendVariants + ? _objc_msgSend_6Stret(stret, _class_NSWindow, + _sel_contentRectForFrameRect_styleMask_, fRect, style.value) + : stret.ref = _objc_msgSend_6(_class_NSWindow, + _sel_contentRectForFrameRect_styleMask_, fRect, style.value); + } + + /// minFrameWidthWithTitle:styleMask: + static double minFrameWidthWithTitle_styleMask_( + objc.NSString title, NSWindowStyleMask style) { + return objc.useMsgSendVariants + ? _objc_msgSend_7Fpret(_class_NSWindow, + _sel_minFrameWidthWithTitle_styleMask_, title.pointer, style.value) + : _objc_msgSend_7(_class_NSWindow, + _sel_minFrameWidthWithTitle_styleMask_, title.pointer, style.value); + } + + /// defaultDepthLimit + static NSWindowDepth getDefaultDepthLimit() { + final _ret = _objc_msgSend_8(_class_NSWindow, _sel_defaultDepthLimit); + return NSWindowDepth.fromValue(_ret); + } + + /// frameRectForContentRect: + void frameRectForContentRect_(ffi.Pointer stret, CGRect contentRect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_frameRectForContentRect_, contentRect) + : stret.ref = _objc_msgSend_9( + this.pointer, _sel_frameRectForContentRect_, contentRect); + } + + /// contentRectForFrameRect: + void contentRectForFrameRect_(ffi.Pointer stret, CGRect frameRect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_contentRectForFrameRect_, frameRect) + : stret.ref = _objc_msgSend_9( + this.pointer, _sel_contentRectForFrameRect_, frameRect); + } + + /// initWithContentRect:styleMask:backing:defer: + NSWindow initWithContentRect_styleMask_backing_defer_(CGRect contentRect, + NSWindowStyleMask style, NSBackingStoreType backingStoreType, bool flag) { + final _ret = _objc_msgSend_10( + this.pointer, + _sel_initWithContentRect_styleMask_backing_defer_, + contentRect, + style.value, + backingStoreType.value, + flag); + return NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithContentRect:styleMask:backing:defer:screen: + NSWindow initWithContentRect_styleMask_backing_defer_screen_( + CGRect contentRect, + NSWindowStyleMask style, + NSBackingStoreType backingStoreType, + bool flag, + NSScreen? screen) { + final _ret = _objc_msgSend_11( + this.pointer, + _sel_initWithContentRect_styleMask_backing_defer_screen_, + contentRect, + style.value, + backingStoreType.value, + flag, + screen?.pointer ?? ffi.nullptr); + return NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + NSWindow? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_31(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// title + objc.NSString get title { + final _ret = _objc_msgSend_13(this.pointer, _sel_title); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTitle: + set title(objc.NSString value) { + return _objc_msgSend_14(this.pointer, _sel_setTitle_, value.pointer); + } + + /// ! + /// Secondary text that may be displayed adjacent to or below the primary title depending on the configuration of the window. + /// A value of empty string will remove the subtitle from the window layout. + objc.NSString get subtitle { + final _ret = _objc_msgSend_13(this.pointer, _sel_subtitle); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// ! + /// Secondary text that may be displayed adjacent to or below the primary title depending on the configuration of the window. + /// A value of empty string will remove the subtitle from the window layout. + set subtitle(objc.NSString value) { + return _objc_msgSend_14(this.pointer, _sel_setSubtitle_, value.pointer); + } + + /// Default value is NSWindowTitleVisible + NSWindowTitleVisibility get titleVisibility { + final _ret = _objc_msgSend_15(this.pointer, _sel_titleVisibility); + return NSWindowTitleVisibility.fromValue(_ret); + } + + /// Default value is NSWindowTitleVisible + set titleVisibility(NSWindowTitleVisibility value) { + return _objc_msgSend_16( + this.pointer, _sel_setTitleVisibility_, value.value); + } + + /// When \c YES, the titlebar doesn't draw its background, allowing all buttons to show through, and "click through" to happen. In general, this is only useful when \c NSFullSizeContentViewWindowMask is set. + bool get titlebarAppearsTransparent { + return _objc_msgSend_17(this.pointer, _sel_titlebarAppearsTransparent); + } + + /// When \c YES, the titlebar doesn't draw its background, allowing all buttons to show through, and "click through" to happen. In general, this is only useful when \c NSFullSizeContentViewWindowMask is set. + set titlebarAppearsTransparent(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setTitlebarAppearsTransparent_, value); + } + + /// Specifies how the titlebar area of the window should appear when the window displays an NSToolbar + NSWindowToolbarStyle get toolbarStyle { + final _ret = _objc_msgSend_19(this.pointer, _sel_toolbarStyle); + return NSWindowToolbarStyle.fromValue(_ret); + } + + /// Specifies how the titlebar area of the window should appear when the window displays an NSToolbar + set toolbarStyle(NSWindowToolbarStyle value) { + return _objc_msgSend_20(this.pointer, _sel_setToolbarStyle_, value.value); + } + + /// The \c contentLayoutRect will return the area inside the window that is for non-obscured content. Typically, this is the same thing as the `contentView`'s frame. However, for windows with the \c NSFullSizeContentViewWindowMask set, there needs to be a way to determine the portion that is not under the toolbar. The \c contentLayoutRect returns the portion of the layout that is not obscured under the toolbar. \c contentLayoutRect is in window coordinates. It is KVO compliant. */ + void getContentLayoutRect(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_21Stret(stret, this.pointer, _sel_contentLayoutRect) + : stret.ref = _objc_msgSend_21(this.pointer, _sel_contentLayoutRect); + } + + /// \c contentLayoutGuide is a corollary to \c contentLayoutRect. It can be used by autolayout constraints to automatically bind to the \c contentLayoutRect. + objc.ObjCObjectBase? get contentLayoutGuide { + final _ret = _objc_msgSend_2(this.pointer, _sel_contentLayoutGuide); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// The following methods allow you to add accessory views to the titlebar/toolbar area of a window. See NSTitlebarAccessoryViewController for more details. + objc.NSArray get titlebarAccessoryViewControllers { + final _ret = + _objc_msgSend_22(this.pointer, _sel_titlebarAccessoryViewControllers); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// The following methods allow you to add accessory views to the titlebar/toolbar area of a window. See NSTitlebarAccessoryViewController for more details. + set titlebarAccessoryViewControllers(objc.NSArray value) { + return _objc_msgSend_23( + this.pointer, _sel_setTitlebarAccessoryViewControllers_, value.pointer); + } + + /// addTitlebarAccessoryViewController: + void addTitlebarAccessoryViewController_( + NSTitlebarAccessoryViewController childViewController) { + _objc_msgSend_24(this.pointer, _sel_addTitlebarAccessoryViewController_, + childViewController.pointer); + } + + /// insertTitlebarAccessoryViewController:atIndex: + void insertTitlebarAccessoryViewController_atIndex_( + NSTitlebarAccessoryViewController childViewController, int index) { + _objc_msgSend_25( + this.pointer, + _sel_insertTitlebarAccessoryViewController_atIndex_, + childViewController.pointer, + index); + } + + /// NOTE: you can use this method, or removeFromParentViewController, which ever is easier. + void removeTitlebarAccessoryViewControllerAtIndex_(int index) { + _objc_msgSend_26(this.pointer, + _sel_removeTitlebarAccessoryViewControllerAtIndex_, index); + } + + /// ! + /// If url is not nil and its path is not empty, the window will show a document icon in the titlebar. + /// If the url represents a filename or other resource with a known icon, that icon will be used as the document icon. Otherwise the default document icon will be used. The icon can be customized using `-[[NSWindow standardWindowButton:NSWindowDocumentIconButton] setImage:customImage]`. If url is not nil and its path is not empty, the window will have a pop-up menu which can be shown via command-click on the area containing the document icon and title. By default, this menu will display the path components of the url. The presence and contents of this menu can be controlled by the delegate method `-[window:shouldPopUpDocumentPathMenu:]` + /// If the url is nil or has an empty path, the window will not show a document icon and will not have a pop-up menu available via command-click. + objc.NSURL? get representedURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_representedURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// ! + /// If url is not nil and its path is not empty, the window will show a document icon in the titlebar. + /// If the url represents a filename or other resource with a known icon, that icon will be used as the document icon. Otherwise the default document icon will be used. The icon can be customized using `-[[NSWindow standardWindowButton:NSWindowDocumentIconButton] setImage:customImage]`. If url is not nil and its path is not empty, the window will have a pop-up menu which can be shown via command-click on the area containing the document icon and title. By default, this menu will display the path components of the url. The presence and contents of this menu can be controlled by the delegate method `-[window:shouldPopUpDocumentPathMenu:]` + /// If the url is nil or has an empty path, the window will not show a document icon and will not have a pop-up menu available via command-click. + set representedURL(objc.NSURL? value) { + return _objc_msgSend_28( + this.pointer, _sel_setRepresentedURL_, value?.pointer ?? ffi.nullptr); + } + + /// representedFilename + objc.NSString get representedFilename { + final _ret = _objc_msgSend_13(this.pointer, _sel_representedFilename); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setRepresentedFilename: + set representedFilename(objc.NSString value) { + return _objc_msgSend_14( + this.pointer, _sel_setRepresentedFilename_, value.pointer); + } + + /// setTitleWithRepresentedFilename: + void setTitleWithRepresentedFilename_(objc.NSString filename) { + _objc_msgSend_29( + this.pointer, _sel_setTitleWithRepresentedFilename_, filename.pointer); + } + + /// isExcludedFromWindowsMenu + bool get excludedFromWindowsMenu { + return _objc_msgSend_17(this.pointer, _sel_isExcludedFromWindowsMenu); + } + + /// setExcludedFromWindowsMenu: + set excludedFromWindowsMenu(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setExcludedFromWindowsMenu_, value); + } + + /// contentView + NSView? get contentView { + final _ret = _objc_msgSend_33(this.pointer, _sel_contentView); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// setContentView: + set contentView(NSView? value) { + return _objc_msgSend_139( + this.pointer, _sel_setContentView_, value?.pointer ?? ffi.nullptr); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// windowNumber + int get windowNumber { + return _objc_msgSend_67(this.pointer, _sel_windowNumber); + } + + /// @note The styleMask can only be set on macOS 10.6 and later. Valid \c styleMask settings have the same restrictions as the \c styleMask passed to `-initWithContentRect:styleMask:backing:defer:`. Some \c styleMask changes will cause the view hierarchy to be rebuilt, since there is a different subclass for the top level view of a borderless window than for the top level view of a titled window. + NSWindowStyleMask get styleMask { + final _ret = _objc_msgSend_177(this.pointer, _sel_styleMask); + return NSWindowStyleMask.fromValue(_ret); + } + + /// @note The styleMask can only be set on macOS 10.6 and later. Valid \c styleMask settings have the same restrictions as the \c styleMask passed to `-initWithContentRect:styleMask:backing:defer:`. Some \c styleMask changes will cause the view hierarchy to be rebuilt, since there is a different subclass for the top level view of a borderless window than for the top level view of a titled window. + set styleMask(NSWindowStyleMask value) { + return _objc_msgSend_178(this.pointer, _sel_setStyleMask_, value.value); + } + + /// fieldEditor:forObject: + NSText? fieldEditor_forObject_(bool createFlag, objc.ObjCObjectBase? object) { + final _ret = _objc_msgSend_198(this.pointer, _sel_fieldEditor_forObject_, + createFlag, object?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : NSText.castFromPointer(_ret, retain: true, release: true); + } + + /// endEditingFor: + void endEditingFor_(objc.ObjCObjectBase? object) { + _objc_msgSend_4( + this.pointer, _sel_endEditingFor_, object?.pointer ?? ffi.nullptr); + } + + /// constrainFrameRect:toScreen: + void constrainFrameRect_toScreen_( + ffi.Pointer stret, CGRect frameRect, NSScreen? screen) { + objc.useMsgSendVariants + ? _objc_msgSend_199Stret( + stret, + this.pointer, + _sel_constrainFrameRect_toScreen_, + frameRect, + screen?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_199( + this.pointer, + _sel_constrainFrameRect_toScreen_, + frameRect, + screen?.pointer ?? ffi.nullptr); + } + + /// setFrame:display: + void setFrame_display_(CGRect frameRect, bool flag) { + _objc_msgSend_200(this.pointer, _sel_setFrame_display_, frameRect, flag); + } + + /// setContentSize: + void setContentSize_(CGSize size) { + _objc_msgSend_46(this.pointer, _sel_setContentSize_, size); + } + + /// setFrameOrigin: + void setFrameOrigin_(CGPoint point) { + _objc_msgSend_49(this.pointer, _sel_setFrameOrigin_, point); + } + + /// setFrameTopLeftPoint: + void setFrameTopLeftPoint_(CGPoint point) { + _objc_msgSend_49(this.pointer, _sel_setFrameTopLeftPoint_, point); + } + + /// cascadeTopLeftFromPoint: + void cascadeTopLeftFromPoint_( + ffi.Pointer stret, CGPoint topLeftPoint) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_cascadeTopLeftFromPoint_, topLeftPoint) + : stret.ref = _objc_msgSend_58( + this.pointer, _sel_cascadeTopLeftFromPoint_, topLeftPoint); + } + + /// frame + void getFrame(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_21Stret(stret, this.pointer, _sel_frame) + : stret.ref = _objc_msgSend_21(this.pointer, _sel_frame); + } + + /// ! Subclasses can override \c animationResizeTime: to control the total time for the frame change. + /// \c newFrame is the rect passed into \c setFrame:display:animate: + double animationResizeTime_(CGRect newFrame) { + return objc.useMsgSendVariants + ? _objc_msgSend_201Fpret( + this.pointer, _sel_animationResizeTime_, newFrame) + : _objc_msgSend_201(this.pointer, _sel_animationResizeTime_, newFrame); + } + + /// ! \c setFrame:display:animate: is equivalent to \c setFrame:display: if the \c animateFlag is NO. + /// If the \c animationFlag is YES, this method will perform a smooth resize of the window, where the total time for the resize is specified by \c -animationResizeTime: + void setFrame_display_animate_( + CGRect frameRect, bool displayFlag, bool animateFlag) { + _objc_msgSend_202(this.pointer, _sel_setFrame_display_animate_, frameRect, + displayFlag, animateFlag); + } + + /// inLiveResize + bool get inLiveResize { + return _objc_msgSend_17(this.pointer, _sel_inLiveResize); + } + + /// resizeIncrements + void getResizeIncrements(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_resizeIncrements) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_resizeIncrements); + } + + /// setResizeIncrements: + set resizeIncrements(CGSize value) { + return _objc_msgSend_197(this.pointer, _sel_setResizeIncrements_, value); + } + + /// aspectRatio + void getAspectRatio(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_aspectRatio) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_aspectRatio); + } + + /// setAspectRatio: + set aspectRatio(CGSize value) { + return _objc_msgSend_197(this.pointer, _sel_setAspectRatio_, value); + } + + /// contentResizeIncrements + void getContentResizeIncrements(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret( + stret, this.pointer, _sel_contentResizeIncrements) + : stret.ref = + _objc_msgSend_88(this.pointer, _sel_contentResizeIncrements); + } + + /// setContentResizeIncrements: + set contentResizeIncrements(CGSize value) { + return _objc_msgSend_197( + this.pointer, _sel_setContentResizeIncrements_, value); + } + + /// contentAspectRatio + void getContentAspectRatio(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_contentAspectRatio) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_contentAspectRatio); + } + + /// setContentAspectRatio: + set contentAspectRatio(CGSize value) { + return _objc_msgSend_197(this.pointer, _sel_setContentAspectRatio_, value); + } + + /// viewsNeedDisplay + bool get viewsNeedDisplay { + return _objc_msgSend_17(this.pointer, _sel_viewsNeedDisplay); + } + + /// setViewsNeedDisplay: + set viewsNeedDisplay(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setViewsNeedDisplay_, value); + } + + /// displayIfNeeded + void displayIfNeeded() { + _objc_msgSend_5(this.pointer, _sel_displayIfNeeded); + } + + /// display + void display() { + _objc_msgSend_5(this.pointer, _sel_display); + } + + /// preservesContentDuringLiveResize + bool get preservesContentDuringLiveResize { + return _objc_msgSend_17( + this.pointer, _sel_preservesContentDuringLiveResize); + } + + /// setPreservesContentDuringLiveResize: + set preservesContentDuringLiveResize(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setPreservesContentDuringLiveResize_, value); + } + + /// update + void update() { + _objc_msgSend_5(this.pointer, _sel_update); + } + + /// makeFirstResponder: + bool makeFirstResponder_(NSResponder? responder) { + return _objc_msgSend_203(this.pointer, _sel_makeFirstResponder_, + responder?.pointer ?? ffi.nullptr); + } + + /// firstResponder is Key Value Observing (KVO) compliant. + NSResponder? get firstResponder { + final _ret = _objc_msgSend_169(this.pointer, _sel_firstResponder); + return _ret.address == 0 + ? null + : NSResponder.castFromPointer(_ret, retain: true, release: true); + } + + /// resizeFlags + NSEventModifierFlags get resizeFlags { + final _ret = _objc_msgSend_66(this.pointer, _sel_resizeFlags); + return NSEventModifierFlags.fromValue(_ret); + } + + /// close + void close() { + _objc_msgSend_5(this.pointer, _sel_close); + } + + /// isReleasedWhenClosed + bool get releasedWhenClosed { + return _objc_msgSend_17(this.pointer, _sel_isReleasedWhenClosed); + } + + /// setReleasedWhenClosed: + set releasedWhenClosed(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setReleasedWhenClosed_, value); + } + + /// miniaturize: + void miniaturize_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_miniaturize_, sender?.pointer ?? ffi.nullptr); + } + + /// deminiaturize: + void deminiaturize_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_deminiaturize_, sender?.pointer ?? ffi.nullptr); + } + + /// isZoomed + bool get zoomed { + return _objc_msgSend_17(this.pointer, _sel_isZoomed); + } + + /// zoom: + void zoom_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_zoom_, sender?.pointer ?? ffi.nullptr); + } + + /// isMiniaturized + bool get miniaturized { + return _objc_msgSend_17(this.pointer, _sel_isMiniaturized); + } + + /// tryToPerform:with: + bool tryToPerform_with_( + ffi.Pointer action, objc.ObjCObjectBase? object) { + return _objc_msgSend_171(this.pointer, _sel_tryToPerform_with_, action, + object?.pointer ?? ffi.nullptr); + } + + /// validRequestorForSendType:returnType: + objc.ObjCObjectBase? validRequestorForSendType_returnType_( + objc.NSString? sendType, objc.NSString? returnType) { + final _ret = _objc_msgSend_172( + this.pointer, + _sel_validRequestorForSendType_returnType_, + sendType?.pointer ?? ffi.nullptr, + returnType?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// backgroundColor + NSColor get backgroundColor { + final _ret = _objc_msgSend_204(this.pointer, _sel_backgroundColor); + return NSColor.castFromPointer(_ret, retain: true, release: true); + } + + /// setBackgroundColor: + set backgroundColor(NSColor value) { + return _objc_msgSend_205( + this.pointer, _sel_setBackgroundColor_, value.pointer); + } + + /// Indicates the thickness of a given border of the window. NSMinYEdge is the bottom edge of the window, while NSMaxYEdge is the top edge of the window. This method may throw an exception for values that don't apply to the current window styleMask; specifically, passing NSMaxYEdge for a non-textured window will always raise. The contentBorder does not include the titlebar or toolbar. + void setContentBorderThickness_forEdge_(double thickness, NSRectEdge edge) { + _objc_msgSend_206(this.pointer, _sel_setContentBorderThickness_forEdge_, + thickness, edge.value); + } + + /// contentBorderThicknessForEdge: + double contentBorderThicknessForEdge_(NSRectEdge edge) { + return objc.useMsgSendVariants + ? _objc_msgSend_207Fpret( + this.pointer, _sel_contentBorderThicknessForEdge_, edge.value) + : _objc_msgSend_207( + this.pointer, _sel_contentBorderThicknessForEdge_, edge.value); + } + + /// setAutorecalculatesContentBorderThickness:forEdge: + void setAutorecalculatesContentBorderThickness_forEdge_( + bool flag, NSRectEdge edge) { + _objc_msgSend_208( + this.pointer, + _sel_setAutorecalculatesContentBorderThickness_forEdge_, + flag, + edge.value); + } + + /// autorecalculatesContentBorderThicknessForEdge: + bool autorecalculatesContentBorderThicknessForEdge_(NSRectEdge edge) { + return _objc_msgSend_209(this.pointer, + _sel_autorecalculatesContentBorderThicknessForEdge_, edge.value); + } + + /// Calling -setMovable with a flag of NO will disable server-side dragging of the window via titlebar or background. -setMovableByWindowBackground:YES is ignored on a window that returns NO from -isMovable. When a window returns NO for -isMovable, it can be assigned to a different space with its relative screen position preserved. Note that a resizable window may still be resized, and the window frame may be changed programmatically. Applications may choose to enable application-controlled window dragging after disabling server-side dragging (perhaps to achieve snapping or pinning) by handling the mouseDown/mouseDragged/mouseUp sequence in -sendEvent: in an NSWindow subclass. Note that a non movable window will also not be moved (or resized) by the system in response to a display reconfiguration. + bool get movable { + return _objc_msgSend_17(this.pointer, _sel_isMovable); + } + + /// Calling -setMovable with a flag of NO will disable server-side dragging of the window via titlebar or background. -setMovableByWindowBackground:YES is ignored on a window that returns NO from -isMovable. When a window returns NO for -isMovable, it can be assigned to a different space with its relative screen position preserved. Note that a resizable window may still be resized, and the window frame may be changed programmatically. Applications may choose to enable application-controlled window dragging after disabling server-side dragging (perhaps to achieve snapping or pinning) by handling the mouseDown/mouseDragged/mouseUp sequence in -sendEvent: in an NSWindow subclass. Note that a non movable window will also not be moved (or resized) by the system in response to a display reconfiguration. + set movable(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setMovable_, value); + } + + /// isMovableByWindowBackground + bool get movableByWindowBackground { + return _objc_msgSend_17(this.pointer, _sel_isMovableByWindowBackground); + } + + /// setMovableByWindowBackground: + set movableByWindowBackground(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setMovableByWindowBackground_, value); + } + + /// hidesOnDeactivate + bool get hidesOnDeactivate { + return _objc_msgSend_17(this.pointer, _sel_hidesOnDeactivate); + } + + /// setHidesOnDeactivate: + set hidesOnDeactivate(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setHidesOnDeactivate_, value); + } + + /// Indicates whether a window can be hidden during `-[NSApplication hide:]`. Default is \c YES. + bool get canHide { + return _objc_msgSend_17(this.pointer, _sel_canHide); + } + + /// Indicates whether a window can be hidden during `-[NSApplication hide:]`. Default is \c YES. + set canHide(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setCanHide_, value); + } + + /// center + void center() { + _objc_msgSend_5(this.pointer, _sel_center); + } + + /// makeKeyAndOrderFront: + void makeKeyAndOrderFront_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_makeKeyAndOrderFront_, + sender?.pointer ?? ffi.nullptr); + } + + /// orderFront: + void orderFront_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_orderFront_, sender?.pointer ?? ffi.nullptr); + } + + /// orderBack: + void orderBack_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_orderBack_, sender?.pointer ?? ffi.nullptr); + } + + /// orderOut: + void orderOut_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_orderOut_, sender?.pointer ?? ffi.nullptr); + } + + /// orderWindow:relativeTo: + void orderWindow_relativeTo_(NSWindowOrderingMode place, int otherWin) { + _objc_msgSend_210( + this.pointer, _sel_orderWindow_relativeTo_, place.value, otherWin); + } + + /// orderFrontRegardless + void orderFrontRegardless() { + _objc_msgSend_5(this.pointer, _sel_orderFrontRegardless); + } + + /// miniwindowImage + NSImage? get miniwindowImage { + final _ret = _objc_msgSend_132(this.pointer, _sel_miniwindowImage); + return _ret.address == 0 + ? null + : NSImage.castFromPointer(_ret, retain: true, release: true); + } + + /// setMiniwindowImage: + set miniwindowImage(NSImage? value) { + return _objc_msgSend_133( + this.pointer, _sel_setMiniwindowImage_, value?.pointer ?? ffi.nullptr); + } + + /// miniwindowTitle + objc.NSString get miniwindowTitle { + final _ret = _objc_msgSend_13(this.pointer, _sel_miniwindowTitle); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setMiniwindowTitle: + set miniwindowTitle(objc.NSString value) { + return _objc_msgSend_14( + this.pointer, _sel_setMiniwindowTitle_, value.pointer); + } + + /// dockTile + NSDockTile get dockTile { + final _ret = _objc_msgSend_211(this.pointer, _sel_dockTile); + return NSDockTile.castFromPointer(_ret, retain: true, release: true); + } + + /// isDocumentEdited + bool get documentEdited { + return _objc_msgSend_17(this.pointer, _sel_isDocumentEdited); + } + + /// setDocumentEdited: + set documentEdited(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setDocumentEdited_, value); + } + + /// isVisible + bool get visible { + return _objc_msgSend_17(this.pointer, _sel_isVisible); + } + + /// isKeyWindow + bool get keyWindow { + return _objc_msgSend_17(this.pointer, _sel_isKeyWindow); + } + + /// isMainWindow + bool get mainWindow { + return _objc_msgSend_17(this.pointer, _sel_isMainWindow); + } + + /// canBecomeKeyWindow + bool get canBecomeKeyWindow { + return _objc_msgSend_17(this.pointer, _sel_canBecomeKeyWindow); + } + + /// canBecomeMainWindow + bool get canBecomeMainWindow { + return _objc_msgSend_17(this.pointer, _sel_canBecomeMainWindow); + } + + /// ! Makes the window key and main if eligible, updating NSAppication's `-keyWindow` and `-mainWindow` properties. + void makeKeyWindow() { + _objc_msgSend_5(this.pointer, _sel_makeKeyWindow); + } + + /// ! Makes the window main if eligible. Updates NSApplication's `-mainWindow` property. + void makeMainWindow() { + _objc_msgSend_5(this.pointer, _sel_makeMainWindow); + } + + /// ! Informs the window that it has become the key window. This method exists as an override point. Do not invoke directly. Instead, invoke `-makeKeyWindow`. + void becomeKeyWindow() { + _objc_msgSend_5(this.pointer, _sel_becomeKeyWindow); + } + + /// ! Informs the window that it has stopped being the key window. This method exists as an override point. Do not invoke directly. Windows automatically receive this message when deactivating or when another window has become key. + void resignKeyWindow() { + _objc_msgSend_5(this.pointer, _sel_resignKeyWindow); + } + + /// ! Informs the window that it has become the main window. This method exists as an override point. Do not invoke directly. Instead, invoke `-makeMainWindow`. + void becomeMainWindow() { + _objc_msgSend_5(this.pointer, _sel_becomeMainWindow); + } + + /// ! Informs the window that it has stopped being the main window. This method exists as an override point. Do not invoke directly. Windows automatically receive this message when deactivating or when another window has become main. + void resignMainWindow() { + _objc_msgSend_5(this.pointer, _sel_resignMainWindow); + } + + /// worksWhenModal + bool get worksWhenModal { + return _objc_msgSend_17(this.pointer, _sel_worksWhenModal); + } + + /// ! Normally, application termination is prohibited when a modal window or sheet is open, without consulting the application delegate. Some windows like the open panel or toolbar customization sheet should not prevent application termination. `-setPreventsApplicationTerminationWhenModal:NO` on a modal window or sheet will override the default behavior and allow application termination to proceed, either through the sudden termination path if enabled, or on to the next step of consulting the application delegate. By default, `-preventsApplicationTerminationWhenModal` returns \c YES + bool get preventsApplicationTerminationWhenModal { + return _objc_msgSend_17( + this.pointer, _sel_preventsApplicationTerminationWhenModal); + } + + /// ! Normally, application termination is prohibited when a modal window or sheet is open, without consulting the application delegate. Some windows like the open panel or toolbar customization sheet should not prevent application termination. `-setPreventsApplicationTerminationWhenModal:NO` on a modal window or sheet will override the default behavior and allow application termination to proceed, either through the sudden termination path if enabled, or on to the next step of consulting the application delegate. By default, `-preventsApplicationTerminationWhenModal` returns \c YES + set preventsApplicationTerminationWhenModal(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setPreventsApplicationTerminationWhenModal_, value); + } + + /// Methods to convert window coordinates to screen coordinates + void convertRectToScreen_(ffi.Pointer stret, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_convertRectToScreen_, rect) + : stret.ref = + _objc_msgSend_9(this.pointer, _sel_convertRectToScreen_, rect); + } + + /// convertRectFromScreen: + void convertRectFromScreen_(ffi.Pointer stret, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_convertRectFromScreen_, rect) + : stret.ref = + _objc_msgSend_9(this.pointer, _sel_convertRectFromScreen_, rect); + } + + /// convertPointToScreen: + void convertPointToScreen_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertPointToScreen_, point) + : stret.ref = + _objc_msgSend_58(this.pointer, _sel_convertPointToScreen_, point); + } + + /// convertPointFromScreen: + void convertPointFromScreen_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertPointFromScreen_, point) + : stret.ref = + _objc_msgSend_58(this.pointer, _sel_convertPointFromScreen_, point); + } + + /// Methods to convert to/from a pixel integral backing store space + void convertRectToBacking_(ffi.Pointer stret, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_convertRectToBacking_, rect) + : stret.ref = + _objc_msgSend_9(this.pointer, _sel_convertRectToBacking_, rect); + } + + /// convertRectFromBacking: + void convertRectFromBacking_(ffi.Pointer stret, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_convertRectFromBacking_, rect) + : stret.ref = + _objc_msgSend_9(this.pointer, _sel_convertRectFromBacking_, rect); + } + + /// convertPointToBacking: + void convertPointToBacking_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertPointToBacking_, point) + : stret.ref = + _objc_msgSend_58(this.pointer, _sel_convertPointToBacking_, point); + } + + /// convertPointFromBacking: + void convertPointFromBacking_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertPointFromBacking_, point) + : stret.ref = _objc_msgSend_58( + this.pointer, _sel_convertPointFromBacking_, point); + } + + /// Use `NSIntegralRectWithOptions()` to produce a backing store pixel aligned rectangle from the given input rectangle in window coordinates. + void backingAlignedRect_options_( + ffi.Pointer stret, CGRect rect, NSAlignmentOptions options) { + objc.useMsgSendVariants + ? _objc_msgSend_57Stret(stret, this.pointer, + _sel_backingAlignedRect_options_, rect, options.value) + : stret.ref = _objc_msgSend_57(this.pointer, + _sel_backingAlignedRect_options_, rect, options.value); + } + + /// Returns the scale factor representing the number of backing store pixels corresponding to each linear unit in window space on this \c NSWindow. This method is provided for rare cases when the explicit scale factor is needed. Please use `-convert*ToBacking:` methods whenever possible. + double get backingScaleFactor { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_backingScaleFactor) + : _objc_msgSend_51(this.pointer, _sel_backingScaleFactor); + } + + /// performClose: + void performClose_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_performClose_, sender?.pointer ?? ffi.nullptr); + } + + /// performMiniaturize: + void performMiniaturize_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_performMiniaturize_, sender?.pointer ?? ffi.nullptr); + } + + /// performZoom: + void performZoom_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_performZoom_, sender?.pointer ?? ffi.nullptr); + } + + /// dataWithEPSInsideRect: + objc.NSData dataWithEPSInsideRect_(CGRect rect) { + final _ret = + _objc_msgSend_212(this.pointer, _sel_dataWithEPSInsideRect_, rect); + return objc.NSData.castFromPointer(_ret, retain: true, release: true); + } + + /// dataWithPDFInsideRect: + objc.NSData dataWithPDFInsideRect_(CGRect rect) { + final _ret = + _objc_msgSend_212(this.pointer, _sel_dataWithPDFInsideRect_, rect); + return objc.NSData.castFromPointer(_ret, retain: true, release: true); + } + + /// print: + void print_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_print_, sender?.pointer ?? ffi.nullptr); + } + + /// ! + /// Default is \c NO. Set to \c YES to allow a window to display tooltips even when the application is in the background. Note that, enabling tooltips in an inactive application will cause the app to do work any time the mouse passes over the window. This can degrade system performance. + /// Returns \c YES if this window displays tooltips even when the application is in the background. To configure this setting you should call `-setAllowsToolTipsWhenApplicationIsInactive:` instead of overriding `-allowsToolTipsWhenApplicationIsInactive`. + bool get allowsToolTipsWhenApplicationIsInactive { + return _objc_msgSend_17( + this.pointer, _sel_allowsToolTipsWhenApplicationIsInactive); + } + + /// ! + /// Default is \c NO. Set to \c YES to allow a window to display tooltips even when the application is in the background. Note that, enabling tooltips in an inactive application will cause the app to do work any time the mouse passes over the window. This can degrade system performance. + /// Returns \c YES if this window displays tooltips even when the application is in the background. To configure this setting you should call `-setAllowsToolTipsWhenApplicationIsInactive:` instead of overriding `-allowsToolTipsWhenApplicationIsInactive`. + set allowsToolTipsWhenApplicationIsInactive(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setAllowsToolTipsWhenApplicationIsInactive_, value); + } + + /// backingType + NSBackingStoreType get backingType { + final _ret = _objc_msgSend_213(this.pointer, _sel_backingType); + return NSBackingStoreType.fromValue(_ret); + } + + /// setBackingType: + set backingType(NSBackingStoreType value) { + return _objc_msgSend_214(this.pointer, _sel_setBackingType_, value.value); + } + + /// level + int get level { + return _objc_msgSend_67(this.pointer, _sel_level); + } + + /// setLevel: + set level(int value) { + return _objc_msgSend_134(this.pointer, _sel_setLevel_, value); + } + + /// depthLimit + NSWindowDepth get depthLimit { + final _ret = _objc_msgSend_8(this.pointer, _sel_depthLimit); + return NSWindowDepth.fromValue(_ret); + } + + /// setDepthLimit: + set depthLimit(NSWindowDepth value) { + return _objc_msgSend_215(this.pointer, _sel_setDepthLimit_, value.value); + } + + /// setDynamicDepthLimit: + void setDynamicDepthLimit_(bool flag) { + _objc_msgSend_144(this.pointer, _sel_setDynamicDepthLimit_, flag); + } + + /// hasDynamicDepthLimit + bool get hasDynamicDepthLimit { + return _objc_msgSend_17(this.pointer, _sel_hasDynamicDepthLimit); + } + + /// ! The screen property returns the best screen for the window. If the window only intersects one screen, it returns that screen. If it intersects more than one screen, then it resolves the tie through based on what space it is mostly on. It may return nil if there are no available screens, or it is completely off screen. + NSScreen? get screen { + final _ret = _objc_msgSend_216(this.pointer, _sel_screen); + return _ret.address == 0 + ? null + : NSScreen.castFromPointer(_ret, retain: true, release: true); + } + + /// deepestScreen + NSScreen? get deepestScreen { + final _ret = _objc_msgSend_216(this.pointer, _sel_deepestScreen); + return _ret.address == 0 + ? null + : NSScreen.castFromPointer(_ret, retain: true, release: true); + } + + /// hasShadow + bool get hasShadow { + return _objc_msgSend_17(this.pointer, _sel_hasShadow); + } + + /// setHasShadow: + set hasShadow(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setHasShadow_, value); + } + + /// invalidateShadow + void invalidateShadow() { + _objc_msgSend_5(this.pointer, _sel_invalidateShadow); + } + + /// alphaValue + double get alphaValue { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_alphaValue) + : _objc_msgSend_51(this.pointer, _sel_alphaValue); + } + + /// setAlphaValue: + set alphaValue(double value) { + return _objc_msgSend_52(this.pointer, _sel_setAlphaValue_, value); + } + + /// isOpaque + bool get opaque { + return _objc_msgSend_17(this.pointer, _sel_isOpaque); + } + + /// setOpaque: + set opaque(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setOpaque_, value); + } + + /// ! `-setSharingType:` specifies whether the window content can be read and/or written from another process. The default sharing type is \c NSWindowSharingReadOnly, which means other processes can read the window content (eg. for window capture) but cannot modify it. If you set your window sharing type to \c NSWindowSharingNone, so that the content cannot be captured, your window will also not be able to participate in a number of system services, so this setting should be used with caution. If you set your window sharing type to \c NSWindowSharingReadWrite, other processes can both read and modify the window content. + NSWindowSharingType get sharingType { + final _ret = _objc_msgSend_217(this.pointer, _sel_sharingType); + return NSWindowSharingType.fromValue(_ret); + } + + /// ! `-setSharingType:` specifies whether the window content can be read and/or written from another process. The default sharing type is \c NSWindowSharingReadOnly, which means other processes can read the window content (eg. for window capture) but cannot modify it. If you set your window sharing type to \c NSWindowSharingNone, so that the content cannot be captured, your window will also not be able to participate in a number of system services, so this setting should be used with caution. If you set your window sharing type to \c NSWindowSharingReadWrite, other processes can both read and modify the window content. + set sharingType(NSWindowSharingType value) { + return _objc_msgSend_218(this.pointer, _sel_setSharingType_, value.value); + } + + /// ! Controls whether threading of view drawing should be enabled for this window. Defaults to \c YES. When this is set to \c YES, AppKit's view system is allowed to perform `-drawRect:` activity for the window's views on threads other than the main thread, for views that have `canDrawConcurrently == YES`. When this is set to \c NO, the window's views will be drawn serially as on 10.5 and earlier, even though some of the views may have `canDrawConcurrently == YES`. + bool get allowsConcurrentViewDrawing { + return _objc_msgSend_17(this.pointer, _sel_allowsConcurrentViewDrawing); + } + + /// ! Controls whether threading of view drawing should be enabled for this window. Defaults to \c YES. When this is set to \c YES, AppKit's view system is allowed to perform `-drawRect:` activity for the window's views on threads other than the main thread, for views that have `canDrawConcurrently == YES`. When this is set to \c NO, the window's views will be drawn serially as on 10.5 and earlier, even though some of the views may have `canDrawConcurrently == YES`. + set allowsConcurrentViewDrawing(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setAllowsConcurrentViewDrawing_, value); + } + + /// displaysWhenScreenProfileChanges + bool get displaysWhenScreenProfileChanges { + return _objc_msgSend_17( + this.pointer, _sel_displaysWhenScreenProfileChanges); + } + + /// setDisplaysWhenScreenProfileChanges: + set displaysWhenScreenProfileChanges(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setDisplaysWhenScreenProfileChanges_, value); + } + + /// ! + /// In recent macOS versions this method does not do anything and should not be called. + void disableScreenUpdatesUntilFlush() { + _objc_msgSend_5(this.pointer, _sel_disableScreenUpdatesUntilFlush); + } + + /// ! This API controls whether the receiver is permitted onscreen before the user has logged in. This property is off by default. Alert panels and windows presented by input managers are examples of windows which should have this property set. + bool get canBecomeVisibleWithoutLogin { + return _objc_msgSend_17(this.pointer, _sel_canBecomeVisibleWithoutLogin); + } + + /// ! This API controls whether the receiver is permitted onscreen before the user has logged in. This property is off by default. Alert panels and windows presented by input managers are examples of windows which should have this property set. + set canBecomeVisibleWithoutLogin(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setCanBecomeVisibleWithoutLogin_, value); + } + + /// collectionBehavior + NSWindowCollectionBehavior get collectionBehavior { + final _ret = _objc_msgSend_219(this.pointer, _sel_collectionBehavior); + return NSWindowCollectionBehavior.fromValue(_ret); + } + + /// setCollectionBehavior: + set collectionBehavior(NSWindowCollectionBehavior value) { + return _objc_msgSend_220( + this.pointer, _sel_setCollectionBehavior_, value.value); + } + + /// ! Provides for per-window control over automatic orderFront/orderOut animation behaviors added in 10.7. Can be set to \c NSWindowAnimationBehaviorNone to disable Appkit's automatic animations for a given window, or to one of the other non-Default \c NSWindowAnimationBehavior values to override AppKit's automatic inference of appropriate animation behavior based on the window's apparent type. + NSWindowAnimationBehavior get animationBehavior { + final _ret = _objc_msgSend_221(this.pointer, _sel_animationBehavior); + return NSWindowAnimationBehavior.fromValue(_ret); + } + + /// ! Provides for per-window control over automatic orderFront/orderOut animation behaviors added in 10.7. Can be set to \c NSWindowAnimationBehaviorNone to disable Appkit's automatic animations for a given window, or to one of the other non-Default \c NSWindowAnimationBehavior values to override AppKit's automatic inference of appropriate animation behavior based on the window's apparent type. + set animationBehavior(NSWindowAnimationBehavior value) { + return _objc_msgSend_222( + this.pointer, _sel_setAnimationBehavior_, value.value); + } + + /// ! Returns \c YES if this window is associated with the active space. For visible windows, this API indicates whether the window is currently visible on the active space. For offscreen windows, it indicates whether ordering the window onscreen would make it bring it onto the active space + bool get onActiveSpace { + return _objc_msgSend_17(this.pointer, _sel_isOnActiveSpace); + } + + /// ! `-toggleFullScreen:` enters or exits for full screen. A window must have \c NSWindowCollectionBehaviorFullScreenAuxiliary or \c NSWindowCollectionBehaviorFullScreenPrimary included in the \c collectionBehavior property; if it does not, this method may simply do nothing. + void toggleFullScreen_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_toggleFullScreen_, sender?.pointer ?? ffi.nullptr); + } + + /// stringWithSavedFrame + objc.NSString get stringWithSavedFrame { + final _ret = _objc_msgSend_13(this.pointer, _sel_stringWithSavedFrame); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setFrameFromString: + void setFrameFromString_(objc.NSString string) { + _objc_msgSend_29(this.pointer, _sel_setFrameFromString_, string.pointer); + } + + /// saveFrameUsingName: + void saveFrameUsingName_(objc.NSString name) { + _objc_msgSend_29(this.pointer, _sel_saveFrameUsingName_, name.pointer); + } + + /// Set force=YES to use setFrameUsingName on a non-resizable window + bool setFrameUsingName_force_(objc.NSString name, bool force) { + return _objc_msgSend_182( + this.pointer, _sel_setFrameUsingName_force_, name.pointer, force); + } + + /// setFrameUsingName: + bool setFrameUsingName_(objc.NSString name) { + return _objc_msgSend_183( + this.pointer, _sel_setFrameUsingName_, name.pointer); + } + + /// setFrameAutosaveName: + bool setFrameAutosaveName_(objc.NSString name) { + return _objc_msgSend_183( + this.pointer, _sel_setFrameAutosaveName_, name.pointer); + } + + /// frameAutosaveName + objc.NSString get frameAutosaveName { + final _ret = _objc_msgSend_13(this.pointer, _sel_frameAutosaveName); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// removeFrameUsingName: + static void removeFrameUsingName_(objc.NSString name) { + _objc_msgSend_29(_class_NSWindow, _sel_removeFrameUsingName_, name.pointer); + } + + /// NOTE: minSize/contentMinSize and maxSize/contentMaxSize are ignored when using autolayout. + void getMinSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_minSize) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_minSize); + } + + /// NOTE: minSize/contentMinSize and maxSize/contentMaxSize are ignored when using autolayout. + set minSize(CGSize value) { + return _objc_msgSend_197(this.pointer, _sel_setMinSize_, value); + } + + /// maxSize + void getMaxSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_maxSize) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_maxSize); + } + + /// setMaxSize: + set maxSize(CGSize value) { + return _objc_msgSend_197(this.pointer, _sel_setMaxSize_, value); + } + + /// contentMinSize + void getContentMinSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_contentMinSize) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_contentMinSize); + } + + /// setContentMinSize: + set contentMinSize(CGSize value) { + return _objc_msgSend_197(this.pointer, _sel_setContentMinSize_, value); + } + + /// contentMaxSize + void getContentMaxSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_contentMaxSize) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_contentMaxSize); + } + + /// setContentMaxSize: + set contentMaxSize(CGSize value) { + return _objc_msgSend_197(this.pointer, _sel_setContentMaxSize_, value); + } + + /// These are the min and max values for a full screen tiled window. + /// + /// In general, one should not need to explicitly set the min/maxFullScreenContentSize. If an application does not change its window content upon entering full screen, then the normal auto layout min and max size will be sufficient, and one should not set these values. If an application does significantly rework the UI in full screen, then it may be necessary to set a min/maxFullScreenContentSize. This size is what is used to determine if a window can fit when it is in full screen in a tile. This property may be used even if the window does not support full screen, but are implicitly opted into supporting a full screen tile based on resizing behavior and window properties (see the collectionBehavior property). By default, the system uses auto layout to determine the min and max sizes. If auto layout is not used, contentMinSize and contentMaxSize are queried. + void getMinFullScreenContentSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret( + stret, this.pointer, _sel_minFullScreenContentSize) + : stret.ref = + _objc_msgSend_88(this.pointer, _sel_minFullScreenContentSize); + } + + /// These are the min and max values for a full screen tiled window. + /// + /// In general, one should not need to explicitly set the min/maxFullScreenContentSize. If an application does not change its window content upon entering full screen, then the normal auto layout min and max size will be sufficient, and one should not set these values. If an application does significantly rework the UI in full screen, then it may be necessary to set a min/maxFullScreenContentSize. This size is what is used to determine if a window can fit when it is in full screen in a tile. This property may be used even if the window does not support full screen, but are implicitly opted into supporting a full screen tile based on resizing behavior and window properties (see the collectionBehavior property). By default, the system uses auto layout to determine the min and max sizes. If auto layout is not used, contentMinSize and contentMaxSize are queried. + set minFullScreenContentSize(CGSize value) { + return _objc_msgSend_197( + this.pointer, _sel_setMinFullScreenContentSize_, value); + } + + /// maxFullScreenContentSize + void getMaxFullScreenContentSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret( + stret, this.pointer, _sel_maxFullScreenContentSize) + : stret.ref = + _objc_msgSend_88(this.pointer, _sel_maxFullScreenContentSize); + } + + /// setMaxFullScreenContentSize: + set maxFullScreenContentSize(CGSize value) { + return _objc_msgSend_197( + this.pointer, _sel_setMaxFullScreenContentSize_, value); + } + + /// deviceDescription + objc.NSDictionary get deviceDescription { + final _ret = _objc_msgSend_223(this.pointer, _sel_deviceDescription); + return objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// windowController + NSWindowController? get windowController { + final _ret = _objc_msgSend_224(this.pointer, _sel_windowController); + return _ret.address == 0 + ? null + : NSWindowController.castFromPointer(_ret, retain: true, release: true); + } + + /// setWindowController: + set windowController(NSWindowController? value) { + return _objc_msgSend_225( + this.pointer, _sel_setWindowController_, value?.pointer ?? ffi.nullptr); + } + + /// This API presents modal-sheets on this window. It replaces NSApp's -beginSheet:modalForWindow:modalDelegate:didEndSelector:contextInfo:. + /// + /// If the window already has a presented sheet, it will queue up sheets presented after that. Once the presented sheet is dismissed, the next queued sheet will be presented, and so forth. + /// Critical sheets will skip this queuing process and be immediately presented on top of existing sheets. The presented sheet will be temporarily disabled and be able to be interacted with after the critical sheet is dismissed, and will then continue as normal. Critical sheets should only be used for time-critical or important events, when the presentation of the sheet needs to be guaranteed (Critical Alerts will automatically use this API). + void beginSheet_completionHandler_( + NSWindow sheetWindow, ObjCBlock_ffiVoid_ffiLong? handler) { + _objc_msgSend_226(this.pointer, _sel_beginSheet_completionHandler_, + sheetWindow.pointer, handler?.pointer ?? ffi.nullptr); + } + + /// beginCriticalSheet:completionHandler: + void beginCriticalSheet_completionHandler_( + NSWindow sheetWindow, ObjCBlock_ffiVoid_ffiLong? handler) { + _objc_msgSend_226(this.pointer, _sel_beginCriticalSheet_completionHandler_, + sheetWindow.pointer, handler?.pointer ?? ffi.nullptr); + } + + /// endSheet: + void endSheet_(NSWindow sheetWindow) { + _objc_msgSend_227(this.pointer, _sel_endSheet_, sheetWindow.pointer); + } + + /// endSheet:returnCode: + void endSheet_returnCode_(NSWindow sheetWindow, int returnCode) { + _objc_msgSend_228(this.pointer, _sel_endSheet_returnCode_, + sheetWindow.pointer, returnCode); + } + + /// An ordered array of the sheets on the window. This consists of the presented sheets in top-to-bottom order, followed by queued sheets in the order they were queued. This does not include nested/sub-sheets. + objc.NSArray get sheets { + final _ret = _objc_msgSend_22(this.pointer, _sel_sheets); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// Returns the top-most sheet if there is one or more sheets, or nil if there is no sheet. + NSWindow? get attachedSheet { + final _ret = _objc_msgSend_32(this.pointer, _sel_attachedSheet); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// isSheet + bool get sheet { + return _objc_msgSend_17(this.pointer, _sel_isSheet); + } + + /// ! + /// Returns the window that the sheet is directly attached to. This is based on the logical attachment of the sheet, not visual attachment. + /// This relationship exists starting when the sheet is begun (using \c NSApplication's `-beginSheet:modalForWindow:modalDelegate:didEndSelector:contextInfo: or NSWindow's -beginSheet:completionHandler:`), and ending once it is ordered out. + /// Returns nil if the window is not a sheet or has no sheet parent. + NSWindow? get sheetParent { + final _ret = _objc_msgSend_32(this.pointer, _sel_sheetParent); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// standardWindowButton:forStyleMask: + static NSButton? standardWindowButton_forStyleMask_( + NSWindowButton b, NSWindowStyleMask styleMask) { + final _ret = _objc_msgSend_229(_class_NSWindow, + _sel_standardWindowButton_forStyleMask_, b.value, styleMask.value); + return _ret.address == 0 + ? null + : NSButton.castFromPointer(_ret, retain: true, release: true); + } + + /// standardWindowButton: + NSButton? standardWindowButton_(NSWindowButton b) { + final _ret = + _objc_msgSend_230(this.pointer, _sel_standardWindowButton_, b.value); + return _ret.address == 0 + ? null + : NSButton.castFromPointer(_ret, retain: true, release: true); + } + + /// addChildWindow:ordered: + void addChildWindow_ordered_(NSWindow childWin, NSWindowOrderingMode place) { + _objc_msgSend_231(this.pointer, _sel_addChildWindow_ordered_, + childWin.pointer, place.value); + } + + /// removeChildWindow: + void removeChildWindow_(NSWindow childWin) { + _objc_msgSend_227(this.pointer, _sel_removeChildWindow_, childWin.pointer); + } + + /// childWindows + objc.NSArray? get childWindows { + final _ret = _objc_msgSend_232(this.pointer, _sel_childWindows); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// parentWindow + NSWindow? get parentWindow { + final _ret = _objc_msgSend_32(this.pointer, _sel_parentWindow); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// setParentWindow: + set parentWindow(NSWindow? value) { + return _objc_msgSend_233( + this.pointer, _sel_setParentWindow_, value?.pointer ?? ffi.nullptr); + } + + /// If set, the receiver will inherit the appearance of that object, as well as use KVO to observe its effectiveAppearance for changes. Typically this is used for child windows that are shown from a parent window or specific view. Defaults to NSApp. + objc.NSObject get appearanceSource { + final _ret = _objc_msgSend_234(this.pointer, _sel_appearanceSource); + return objc.NSObject.castFromPointer(_ret, retain: true, release: true); + } + + /// If set, the receiver will inherit the appearance of that object, as well as use KVO to observe its effectiveAppearance for changes. Typically this is used for child windows that are shown from a parent window or specific view. Defaults to NSApp. + set appearanceSource(objc.NSObject value) { + return _objc_msgSend_235( + this.pointer, _sel_setAppearanceSource_, value.pointer); + } + + /// colorSpace + NSColorSpace? get colorSpace { + final _ret = _objc_msgSend_236(this.pointer, _sel_colorSpace); + return _ret.address == 0 + ? null + : NSColorSpace.castFromPointer(_ret, retain: true, release: true); + } + + /// setColorSpace: + set colorSpace(NSColorSpace? value) { + return _objc_msgSend_237( + this.pointer, _sel_setColorSpace_, value?.pointer ?? ffi.nullptr); + } + + /// ! `-canRepresentDisplayGamut:` returns \c YES if the colorSpace of the receiving window, and the \c colorSpace of the screen containing that window, are capable of representing the given display gamut + bool canRepresentDisplayGamut_(NSDisplayGamut displayGamut) { + return _objc_msgSend_238( + this.pointer, _sel_canRepresentDisplayGamut_, displayGamut.value); + } + + /// ! `+windowNumbersWithOptions:` returns an autoreleased array of \c NSNumbers containing windowNumbers for all visible windows satisfying options. If no options are specified, only visible windows belonging to the calling application and on the active space are included. If options include \c NSWindowNumberListAllApplications, visible windows belonging to all applications are included. If options include \c NSWindowNumberListAllSpaces, visible windows on all spaces are included. Windows on the active space are returned in z-order. + /// Examples: + /// To get an array of windowNumbers visible on the current space and belonging to the calling application: + /// `windowNumbers = [NSWindow windowNumbersWithOptions:0];` + /// To get an array of windowNumbers visible on any space and belonging to any application: + /// `windowNumbers = [NSWindow windowNumbersWithOptions:NSWindowNumberListAllApplications|NSWindowNumberListAllSpaces];` + /// To get an array of windowNumbers visible on any space and belonging to the calling application: + /// `windowNumbers = [NSWindow windowNumbersWithOptions:NSWindowNumberListAllSpaces];` + static objc.NSArray? windowNumbersWithOptions_( + NSWindowNumberListOptions options) { + final _ret = _objc_msgSend_239( + _class_NSWindow, _sel_windowNumbersWithOptions_, options.value); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// ! `+windowNumberAtPoint:belowWindowWithWindowNumber:` returns the number of the frontmost window that would be hit by a mouseDown at the screen location "point". "windowNum" can be specified to exclude a given window along with all windows above it, and may belong to any application. If no windows are to be excluded, specify 0 for "windowNum". The windowNumber returned may correspond to a window in another application. + static int windowNumberAtPoint_belowWindowWithWindowNumber_( + CGPoint point, int windowNumber) { + return _objc_msgSend_240( + _class_NSWindow, + _sel_windowNumberAtPoint_belowWindowWithWindowNumber_, + point, + windowNumber); + } + + /// occlusionState + NSWindowOcclusionState get occlusionState { + final _ret = _objc_msgSend_241(this.pointer, _sel_occlusionState); + return NSWindowOcclusionState.fromValue(_ret); + } + + /// ! Specifies the style of separator displayed between the window's titlebar and content. + /// + /// The default value is NSTitlebarSeparatorStyleAutomatic. Changing this value will override any preference made by `NSSplitViewItem`. + NSTitlebarSeparatorStyle get titlebarSeparatorStyle { + final _ret = _objc_msgSend_242(this.pointer, _sel_titlebarSeparatorStyle); + return NSTitlebarSeparatorStyle.fromValue(_ret); + } + + /// ! Specifies the style of separator displayed between the window's titlebar and content. + /// + /// The default value is NSTitlebarSeparatorStyleAutomatic. Changing this value will override any preference made by `NSSplitViewItem`. + set titlebarSeparatorStyle(NSTitlebarSeparatorStyle value) { + return _objc_msgSend_243( + this.pointer, _sel_setTitlebarSeparatorStyle_, value.value); + } + + /// ! The main content view controller for the window. This provides the contentView of the window. Assigning this value will remove the existing contentView and will make the contentViewController.view the main contentView for the window. The default value is nil. The contentViewController only controls the contentView, and not the title of the window. The window title can easily be bound to the contentViewController with the following: [window bind:NSTitleBinding toObject:contentViewController withKeyPath:@"title" options:nil]. Setting the contentViewController will cause the window to resize based on the current size of the contentViewController. Autolayout should be used to restrict the size of the window. The value of the contentViewController is encoded in the NIB. Directly assigning a contentView will clear out the contentViewController. + NSViewController? get contentViewController { + final _ret = _objc_msgSend_244(this.pointer, _sel_contentViewController); + return _ret.address == 0 + ? null + : NSViewController.castFromPointer(_ret, retain: true, release: true); + } + + /// ! The main content view controller for the window. This provides the contentView of the window. Assigning this value will remove the existing contentView and will make the contentViewController.view the main contentView for the window. The default value is nil. The contentViewController only controls the contentView, and not the title of the window. The window title can easily be bound to the contentViewController with the following: [window bind:NSTitleBinding toObject:contentViewController withKeyPath:@"title" options:nil]. Setting the contentViewController will cause the window to resize based on the current size of the contentViewController. Autolayout should be used to restrict the size of the window. The value of the contentViewController is encoded in the NIB. Directly assigning a contentView will clear out the contentViewController. + set contentViewController(NSViewController? value) { + return _objc_msgSend_245(this.pointer, _sel_setContentViewController_, + value?.pointer ?? ffi.nullptr); + } + + /// ! Convenience method for creating an autoreleased titled window with the given contentViewController. A basic NSWindow with the following attributes is made: titled, closable, resizable, miniaturizable. The window's title is automatically bound to the contentViewController's title. The size of the window can easily be controlled by utilizing autolayout and applying size constraints to the view (or its subviews). The window has isReleasedWhenClosed set to NO, and it must be explicitly retained to keep the window instance alive. To have it automatically be freed when it is closed, do the following: [window retain] and [window setReleasedWhenClosed:YES]. + static NSWindow windowWithContentViewController_( + NSViewController contentViewController) { + final _ret = _objc_msgSend_246(_class_NSWindow, + _sel_windowWithContentViewController_, contentViewController.pointer); + return NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// ! Call to start a drag (moving the window) in the Window Server process. In general, this can be done after a mouseDown event has come in and been examined by an application or view. The view may determine it wants to allow that portion of the window to start a window drag, and can hand off the work to the Window Server process by calling this method. This allows the window to participate in space switching, and other system features. Pass the original mouseDown event to the method. The method will return right away, and a mouseUp may not get sent. + void performWindowDragWithEvent_(NSEvent event) { + _objc_msgSend_173( + this.pointer, _sel_performWindowDragWithEvent_, event.pointer); + } + + /// initialFirstResponder + NSView? get initialFirstResponder { + final _ret = _objc_msgSend_33(this.pointer, _sel_initialFirstResponder); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// setInitialFirstResponder: + set initialFirstResponder(NSView? value) { + return _objc_msgSend_139(this.pointer, _sel_setInitialFirstResponder_, + value?.pointer ?? ffi.nullptr); + } + + /// selectNextKeyView: + void selectNextKeyView_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_selectNextKeyView_, sender?.pointer ?? ffi.nullptr); + } + + /// selectPreviousKeyView: + void selectPreviousKeyView_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_selectPreviousKeyView_, + sender?.pointer ?? ffi.nullptr); + } + + /// selectKeyViewFollowingView: + void selectKeyViewFollowingView_(NSView view) { + _objc_msgSend_40( + this.pointer, _sel_selectKeyViewFollowingView_, view.pointer); + } + + /// selectKeyViewPrecedingView: + void selectKeyViewPrecedingView_(NSView view) { + _objc_msgSend_40( + this.pointer, _sel_selectKeyViewPrecedingView_, view.pointer); + } + + /// keyViewSelectionDirection + NSSelectionDirection get keyViewSelectionDirection { + final _ret = + _objc_msgSend_247(this.pointer, _sel_keyViewSelectionDirection); + return NSSelectionDirection.fromValue(_ret); + } + + /// defaultButtonCell + NSButtonCell? get defaultButtonCell { + final _ret = _objc_msgSend_248(this.pointer, _sel_defaultButtonCell); + return _ret.address == 0 + ? null + : NSButtonCell.castFromPointer(_ret, retain: true, release: true); + } + + /// setDefaultButtonCell: + set defaultButtonCell(NSButtonCell? value) { + return _objc_msgSend_249(this.pointer, _sel_setDefaultButtonCell_, + value?.pointer ?? ffi.nullptr); + } + + /// disableKeyEquivalentForDefaultButtonCell + void disableKeyEquivalentForDefaultButtonCell() { + _objc_msgSend_5( + this.pointer, _sel_disableKeyEquivalentForDefaultButtonCell); + } + + /// enableKeyEquivalentForDefaultButtonCell + void enableKeyEquivalentForDefaultButtonCell() { + _objc_msgSend_5(this.pointer, _sel_enableKeyEquivalentForDefaultButtonCell); + } + + /// autorecalculatesKeyViewLoop + bool get autorecalculatesKeyViewLoop { + return _objc_msgSend_17(this.pointer, _sel_autorecalculatesKeyViewLoop); + } + + /// setAutorecalculatesKeyViewLoop: + set autorecalculatesKeyViewLoop(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setAutorecalculatesKeyViewLoop_, value); + } + + /// recalculateKeyViewLoop + void recalculateKeyViewLoop() { + _objc_msgSend_5(this.pointer, _sel_recalculateKeyViewLoop); + } + + /// toolbar + NSToolbar? get toolbar { + final _ret = _objc_msgSend_250(this.pointer, _sel_toolbar); + return _ret.address == 0 + ? null + : NSToolbar.castFromPointer(_ret, retain: true, release: true); + } + + /// setToolbar: + set toolbar(NSToolbar? value) { + return _objc_msgSend_251( + this.pointer, _sel_setToolbar_, value?.pointer ?? ffi.nullptr); + } + + /// toggleToolbarShown: + void toggleToolbarShown_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_toggleToolbarShown_, sender?.pointer ?? ffi.nullptr); + } + + /// runToolbarCustomizationPalette: + void runToolbarCustomizationPalette_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_runToolbarCustomizationPalette_, + sender?.pointer ?? ffi.nullptr); + } + + /// showsToolbarButton + bool get showsToolbarButton { + return _objc_msgSend_17(this.pointer, _sel_showsToolbarButton); + } + + /// setShowsToolbarButton: + set showsToolbarButton(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setShowsToolbarButton_, value); + } + + /// ! Allows automatic window tabbing when the value is \c YES. By default, this will be set to \c YES, but applications can explicitly opt out of all automatic tabbing by setting it to NO, and can still adopted explicit window tabbing, if desired. + static bool getAllowsAutomaticWindowTabbing() { + return _objc_msgSend_17(_class_NSWindow, _sel_allowsAutomaticWindowTabbing); + } + + /// ! Allows automatic window tabbing when the value is \c YES. By default, this will be set to \c YES, but applications can explicitly opt out of all automatic tabbing by setting it to NO, and can still adopted explicit window tabbing, if desired. + static void setAllowsAutomaticWindowTabbing(bool value) { + return _objc_msgSend_18( + _class_NSWindow, _sel_setAllowsAutomaticWindowTabbing_, value); + } + + /// ! Returns the user's tabbing preference as set in System Preferences. This value should be queried anytime a new window is made to see if the user wants to automatically show it in tabs. + static NSWindowUserTabbingPreference getUserTabbingPreference() { + final _ret = _objc_msgSend_252(_class_NSWindow, _sel_userTabbingPreference); + return NSWindowUserTabbingPreference.fromValue(_ret); + } + + /// ! Get and set the tabbing mode for this window. This should be set before a window is shown. The default value is \c NSWindowTabbingModeAutomatic. When the value is \c NSWindowTabbingModeAutomatic, the system will look at the \c userTabbingPreference and automatically tab windows together based on the tabbingIdentifier, when it is appropriate to do so. + NSWindowTabbingMode get tabbingMode { + final _ret = _objc_msgSend_253(this.pointer, _sel_tabbingMode); + return NSWindowTabbingMode.fromValue(_ret); + } + + /// ! Get and set the tabbing mode for this window. This should be set before a window is shown. The default value is \c NSWindowTabbingModeAutomatic. When the value is \c NSWindowTabbingModeAutomatic, the system will look at the \c userTabbingPreference and automatically tab windows together based on the tabbingIdentifier, when it is appropriate to do so. + set tabbingMode(NSWindowTabbingMode value) { + return _objc_msgSend_254(this.pointer, _sel_setTabbingMode_, value.value); + } + + /// ! Windows with the same \c tabbingIdentifier will have the ability to be tabbed together when a window is being shown. This allows aggregation of similar windows. By default, the \c tabbingIdentifier will be generated based on inherent window properties, such as the window class name, the delegate class name, the window controller class name, and some additional state. Windows can be explicitly made to group together by using the same \c tabbingIdentifier. + objc.NSString get tabbingIdentifier { + final _ret = _objc_msgSend_13(this.pointer, _sel_tabbingIdentifier); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// ! Windows with the same \c tabbingIdentifier will have the ability to be tabbed together when a window is being shown. This allows aggregation of similar windows. By default, the \c tabbingIdentifier will be generated based on inherent window properties, such as the window class name, the delegate class name, the window controller class name, and some additional state. Windows can be explicitly made to group together by using the same \c tabbingIdentifier. + set tabbingIdentifier(objc.NSString value) { + return _objc_msgSend_14( + this.pointer, _sel_setTabbingIdentifier_, value.pointer); + } + + /// ! Actions that can be called to perform various tabbed window behaviors. UI that is hooked up to these items can be automatically validated by calling `NSWindow`'s \c validateUserInterfaceItem. + void selectNextTab_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_selectNextTab_, sender?.pointer ?? ffi.nullptr); + } + + /// selectPreviousTab: + void selectPreviousTab_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_selectPreviousTab_, sender?.pointer ?? ffi.nullptr); + } + + /// moveTabToNewWindow: + void moveTabToNewWindow_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_moveTabToNewWindow_, sender?.pointer ?? ffi.nullptr); + } + + /// mergeAllWindows: + void mergeAllWindows_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_mergeAllWindows_, sender?.pointer ?? ffi.nullptr); + } + + /// toggleTabBar: + void toggleTabBar_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_toggleTabBar_, sender?.pointer ?? ffi.nullptr); + } + + /// ! Toggle the Tab Picker / Tab Overview UI which is invoked via "Show All Tabs". Performs the toggle in an animated fashion. Use `tabGroup.isOverviewVisible` to find out if it is visible or not at a given time. + void toggleTabOverview_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_toggleTabOverview_, sender?.pointer ?? ffi.nullptr); + } + + /// ! This is now a cover for `self.tabGroup.windows`, but will return nil if the window is not showing a tab bar. + objc.NSArray? get tabbedWindows { + final _ret = _objc_msgSend_232(this.pointer, _sel_tabbedWindows); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// ! This is now a cover for `-[self.tabGroup addWindow:]`, which allows more precise placement. + void addTabbedWindow_ordered_(NSWindow window, NSWindowOrderingMode ordered) { + _objc_msgSend_231(this.pointer, _sel_addTabbedWindow_ordered_, + window.pointer, ordered.value); + } + + /// ! Access the properties for this window when it is a tabbed window environment. See the \c NSWindowTab header and comments for more information. + NSWindowTab get tab { + final _ret = _objc_msgSend_255(this.pointer, _sel_tab); + return NSWindowTab.castFromPointer(_ret, retain: true, release: true); + } + + /// ! Represents a tab group of windows. This \c tabGroup is lazily created on demand. + NSWindowTabGroup? get tabGroup { + final _ret = _objc_msgSend_256(this.pointer, _sel_tabGroup); + return _ret.address == 0 + ? null + : NSWindowTabGroup.castFromPointer(_ret, retain: true, release: true); + } + + /// ! + /// @abstract Attempt to move window sharing (i.e. within a SharePlay session) from the receiver to another window. In response to this request, the user may choose to transfer sharing to the new window, or simply stop sharing the content. + /// @param window + /// A window that is replacing the reciever in representing the user's current activity. + /// @param completionHandler + /// A completion block that is called after the request finishes. + /// @param error + /// In the event of a failed transfer request, a non-nil error contains details about the failure. + void transferWindowSharingToWindow_completionHandler_( + NSWindow window, ObjCBlock_ffiVoid_NSError completionHandler) { + _objc_msgSend_257( + this.pointer, + _sel_transferWindowSharingToWindow_completionHandler_, + window.pointer, + completionHandler.pointer); + } + + /// ! + /// @abstract Indicates whether the receiver is the subject of an active SharePlay sharing session. + bool get hasActiveWindowSharingSession { + return _objc_msgSend_17(this.pointer, _sel_hasActiveWindowSharingSession); + } + + /// ! Retrieve the layout direction of the window titlebar: this includes the standard window buttons (close/minimize/maximize buttons) and the title for this window. In general, this will return "right to left" (RTL) if the primary system language is RTL. The layout direction may be RTL even in applications that do not have a RTL language localization. This value should be utilized if an application uses titlebarAppearsTransparent and places controls underneath the titlebar. + NSUserInterfaceLayoutDirection get windowTitlebarLayoutDirection { + final _ret = + _objc_msgSend_160(this.pointer, _sel_windowTitlebarLayoutDirection); + return NSUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// ! Tracks events matching the supplied mask with the supplied tracking handler until the tracking handler explicitly terminates tracking. Each event is removed from the event queue then passed to the tracking handler. If a matching event does not exist in the event queue, then the main thread blocks in the specified runloop mode until an event of the requested type is received or the timeout expires. If the timeout expires, the tracking handler is called with a nil event. A negative timeout is interpreted as 0. Use \c NSEventDurationForever to never timeout. Tracking continues until `*stop` is set to \c YES. Calls to `-nextEventMatchingMask:…` are allowed inside the trackingHandler block. This method returns once tracking is terminated. + void trackEventsMatchingMask_timeout_mode_handler_( + NSEventMask mask, + double timeout, + objc.NSString mode, + ObjCBlock_ffiVoid_NSEvent_bool trackingHandler) { + _objc_msgSend_258( + this.pointer, + _sel_trackEventsMatchingMask_timeout_mode_handler_, + mask.value, + timeout, + mode.pointer, + trackingHandler.pointer); + } + + /// nextEventMatchingMask: + NSEvent? nextEventMatchingMask_(NSEventMask mask) { + final _ret = _objc_msgSend_259( + this.pointer, _sel_nextEventMatchingMask_, mask.value); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// nextEventMatchingMask:untilDate:inMode:dequeue: + NSEvent? nextEventMatchingMask_untilDate_inMode_dequeue_(NSEventMask mask, + objc.NSDate? expiration, objc.NSString mode, bool deqFlag) { + final _ret = _objc_msgSend_260( + this.pointer, + _sel_nextEventMatchingMask_untilDate_inMode_dequeue_, + mask.value, + expiration?.pointer ?? ffi.nullptr, + mode.pointer, + deqFlag); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// discardEventsMatchingMask:beforeEvent: + void discardEventsMatchingMask_beforeEvent_( + NSEventMask mask, NSEvent? lastEvent) { + _objc_msgSend_261(this.pointer, _sel_discardEventsMatchingMask_beforeEvent_, + mask.value, lastEvent?.pointer ?? ffi.nullptr); + } + + /// postEvent:atStart: + void postEvent_atStart_(NSEvent event, bool flag) { + _objc_msgSend_262( + this.pointer, _sel_postEvent_atStart_, event.pointer, flag); + } + + /// sendEvent: + void sendEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_sendEvent_, event.pointer); + } + + /// currentEvent + NSEvent? get currentEvent { + final _ret = _objc_msgSend_263(this.pointer, _sel_currentEvent); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// acceptsMouseMovedEvents + bool get acceptsMouseMovedEvents { + return _objc_msgSend_17(this.pointer, _sel_acceptsMouseMovedEvents); + } + + /// setAcceptsMouseMovedEvents: + set acceptsMouseMovedEvents(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setAcceptsMouseMovedEvents_, value); + } + + /// ignoresMouseEvents + bool get ignoresMouseEvents { + return _objc_msgSend_17(this.pointer, _sel_ignoresMouseEvents); + } + + /// setIgnoresMouseEvents: + set ignoresMouseEvents(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setIgnoresMouseEvents_, value); + } + + /// mouseLocationOutsideOfEventStream + void getMouseLocationOutsideOfEventStream(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_70Stret( + stret, this.pointer, _sel_mouseLocationOutsideOfEventStream) + : stret.ref = _objc_msgSend_70( + this.pointer, _sel_mouseLocationOutsideOfEventStream); + } + + /// disableCursorRects + void disableCursorRects() { + _objc_msgSend_5(this.pointer, _sel_disableCursorRects); + } + + /// enableCursorRects + void enableCursorRects() { + _objc_msgSend_5(this.pointer, _sel_enableCursorRects); + } + + /// discardCursorRects + void discardCursorRects() { + _objc_msgSend_5(this.pointer, _sel_discardCursorRects); + } + + /// areCursorRectsEnabled + bool get areCursorRectsEnabled { + return _objc_msgSend_17(this.pointer, _sel_areCursorRectsEnabled); + } + + /// invalidateCursorRectsForView: + void invalidateCursorRectsForView_(NSView view) { + _objc_msgSend_40( + this.pointer, _sel_invalidateCursorRectsForView_, view.pointer); + } + + /// resetCursorRects + void resetCursorRects() { + _objc_msgSend_5(this.pointer, _sel_resetCursorRects); + } + + /// dragImage:at:offset:event:pasteboard:source:slideBack: + void dragImage_at_offset_event_pasteboard_source_slideBack_( + NSImage image, + CGPoint baseLocation, + CGSize initialOffset, + NSEvent event, + NSPasteboard pboard, + objc.ObjCObjectBase sourceObj, + bool slideFlag) { + _objc_msgSend_279( + this.pointer, + _sel_dragImage_at_offset_event_pasteboard_source_slideBack_, + image.pointer, + baseLocation, + initialOffset, + event.pointer, + pboard.pointer, + sourceObj.pointer, + slideFlag); + } + + /// registerForDraggedTypes: + void registerForDraggedTypes_(objc.NSArray newTypes) { + _objc_msgSend_280( + this.pointer, _sel_registerForDraggedTypes_, newTypes.pointer); + } + + /// unregisterDraggedTypes + void unregisterDraggedTypes() { + _objc_msgSend_5(this.pointer, _sel_unregisterDraggedTypes); + } + + /// WindowRef + NSWindow? initWithWindowRef_(ffi.Pointer windowRef) { + final _ret = + _objc_msgSend_281(this.pointer, _sel_initWithWindowRef_, windowRef); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// WindowRef + ffi.Pointer get windowRef { + return _objc_msgSend_75(this.pointer, _sel_windowRef); + } + + /// Returns a new display link whose callback will be invoked in-sync with the display the window is on. If the window is not on any display the callback will not be invoked. + CADisplayLink displayLinkWithTarget_selector_( + objc.ObjCObjectBase target, ffi.Pointer selector) { + final _ret = _objc_msgSend_282(this.pointer, + _sel_displayLinkWithTarget_selector_, target.pointer, selector); + return CADisplayLink.castFromPointer(_ret, retain: true, release: true); + } + + /// cacheImageInRect: + void cacheImageInRect_(CGRect rect) { + _objc_msgSend_60(this.pointer, _sel_cacheImageInRect_, rect); + } + + /// restoreCachedImage + void restoreCachedImage() { + _objc_msgSend_5(this.pointer, _sel_restoreCachedImage); + } + + /// discardCachedImage + void discardCachedImage() { + _objc_msgSend_5(this.pointer, _sel_discardCachedImage); + } + + /// menuChanged: + static void menuChanged_(NSMenu menu) { + _objc_msgSend_283(_class_NSWindow, _sel_menuChanged_, menu.pointer); + } + + /// gState is unused and should not be called. + int gState() { + return _objc_msgSend_67(this.pointer, _sel_gState); + } + + /// The base/screen conversion methods are deprecated in 10.7 and later. Please use one of convertRectToScreen:, convertRectFromScreen:, convertPointToScreen:, or convertPointFromScreen: instead. + void convertBaseToScreen_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertBaseToScreen_, point) + : stret.ref = + _objc_msgSend_58(this.pointer, _sel_convertBaseToScreen_, point); + } + + /// convertScreenToBase: + void convertScreenToBase_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertScreenToBase_, point) + : stret.ref = + _objc_msgSend_58(this.pointer, _sel_convertScreenToBase_, point); + } + + /// This method is deprecated and should not be used by applications targeting Mac OS X 10.7 or later. + /// The implementation of this method will always return 1.0. Please use -convertRectToBacking: and -backingScaleFactor instead. + double userSpaceScaleFactor() { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_userSpaceScaleFactor) + : _objc_msgSend_51(this.pointer, _sel_userSpaceScaleFactor); + } + + /// useOptimizedDrawing: + void useOptimizedDrawing_(bool flag) { + _objc_msgSend_144(this.pointer, _sel_useOptimizedDrawing_, flag); + } + + /// canStoreColor has not been needed or used in a while and is deprecated. + bool canStoreColor() { + return _objc_msgSend_17(this.pointer, _sel_canStoreColor); + } + + /// disableFlushWindow + void disableFlushWindow() { + _objc_msgSend_5(this.pointer, _sel_disableFlushWindow); + } + + /// enableFlushWindow + void enableFlushWindow() { + _objc_msgSend_5(this.pointer, _sel_enableFlushWindow); + } + + /// isFlushWindowDisabled + bool get flushWindowDisabled { + return _objc_msgSend_17(this.pointer, _sel_isFlushWindowDisabled); + } + + /// flushWindow + void flushWindow() { + _objc_msgSend_5(this.pointer, _sel_flushWindow); + } + + /// flushWindowIfNeeded + void flushWindowIfNeeded() { + _objc_msgSend_5(this.pointer, _sel_flushWindowIfNeeded); + } + + /// isAutodisplay + bool get autodisplay { + return _objc_msgSend_17(this.pointer, _sel_isAutodisplay); + } + + /// setAutodisplay: + set autodisplay(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setAutodisplay_, value); + } + + /// Returns NSGraphicsContext used to render the receiver's content on the screen for the calling thread. + NSGraphicsContext? get graphicsContext { + final _ret = _objc_msgSend_68(this.pointer, _sel_graphicsContext); + return _ret.address == 0 + ? null + : NSGraphicsContext.castFromPointer(_ret, retain: true, release: true); + } + + /// isOneShot + bool get oneShot { + return _objc_msgSend_17(this.pointer, _sel_isOneShot); + } + + /// setOneShot: + set oneShot(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setOneShot_, value); + } + + /// preferredBackingLocation + NSWindowBackingLocation get preferredBackingLocation { + final _ret = _objc_msgSend_284(this.pointer, _sel_preferredBackingLocation); + return NSWindowBackingLocation.fromValue(_ret); + } + + /// setPreferredBackingLocation: + set preferredBackingLocation(NSWindowBackingLocation value) { + return _objc_msgSend_285( + this.pointer, _sel_setPreferredBackingLocation_, value.value); + } + + /// backingLocation + NSWindowBackingLocation get backingLocation { + final _ret = _objc_msgSend_284(this.pointer, _sel_backingLocation); + return NSWindowBackingLocation.fromValue(_ret); + } + + /// showsResizeIndicator is soft-deprecated in 10.14. It is ignored on 10.7 and newer, and should not be used. + bool get showsResizeIndicator { + return _objc_msgSend_17(this.pointer, _sel_showsResizeIndicator); + } + + /// showsResizeIndicator is soft-deprecated in 10.14. It is ignored on 10.7 and newer, and should not be used. + set showsResizeIndicator(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setShowsResizeIndicator_, value); + } + + /// init + NSWindow init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSWindow new1() { + final _ret = _objc_msgSend_34(_class_NSWindow, _sel_new); + return NSWindow.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSWindow allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSWindow, _sel_allocWithZone_, zone); + return NSWindow.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSWindow alloc() { + final _ret = _objc_msgSend_34(_class_NSWindow, _sel_alloc); + return NSWindow.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSWindow = objc.getClass("NSWindow"); + +final class CGRect extends ffi.Struct { + external CGPoint origin; + + external CGSize size; +} + +final class CGPoint extends ffi.Struct { + @ffi.Double() + external double x; + + @ffi.Double() + external double y; +} + +final class CGSize extends ffi.Struct { + @ffi.Double() + external double width; + + @ffi.Double() + external double height; +} + +/// ! +/// @typedef NSWindowStyleMask +/// +/// @const NSWindowStyleMaskBorderless +/// @const NSWindowStyleMaskTitled +/// @const NSWindowStyleMaskClosable +/// @const NSWindowStyleMaskMiniaturizable +/// @const NSWindowStyleMaskResizable +/// @const NSWindowStyleMaskTexturedBackground Textured window style is deprecated and should no longer be used. Specifies a window with textured background. Textured windows generally don't draw a top border line under the titlebar/toolbar. To get that line, use the \c NSUnifiedTitleAndToolbarWindowMask mask. +/// @const NSWindowStyleMaskUnifiedTitleAndToolbar Specifies a window whose titlebar and toolbar have a unified look - that is, a continuous background. Under the titlebar and toolbar a horizontal separator line will appear. +/// @const NSWindowStyleMaskFullScreen When present, the window will appear full screen. This mask is automatically toggled when \c -toggleFullScreen: is called. +/// @const NSWindowStyleMaskFullSizeContentView If set, the \c contentView will consume the full size of the window; it can be combined with other window style masks, but is only respected for windows with a titlebar. Utilizing this mask opts-in to layer-backing. Utilize the \c contentLayoutRect or auto-layout \c contentLayoutGuide to layout views underneath the titlebar/toolbar area. +/// @const NSWindowStyleMaskUtilityWindow Only applicable for \c NSPanel (or a subclass thereof). +/// @const NSWindowStyleMaskDocModalWindow Only applicable for \c NSPanel (or a subclass thereof). +/// @const NSWindowStyleMaskNonactivatingPanel Specifies that a panel that does not activate the owning application. Only applicable for \c NSPanel (or a subclass thereof). +/// @const NSWindowStyleMaskHUDWindow Specifies a heads up display panel. Only applicable for \c NSPanel (or a subclass thereof). +enum NSWindowStyleMask { + NSWindowStyleMaskBorderless(0), + NSWindowStyleMaskTitled(1), + NSWindowStyleMaskClosable(2), + NSWindowStyleMaskMiniaturizable(4), + NSWindowStyleMaskResizable(8), + NSWindowStyleMaskTexturedBackground(256), + NSWindowStyleMaskUnifiedTitleAndToolbar(4096), + NSWindowStyleMaskFullScreen(16384), + NSWindowStyleMaskFullSizeContentView(32768), + NSWindowStyleMaskUtilityWindow(16), + NSWindowStyleMaskDocModalWindow(64), + NSWindowStyleMaskNonactivatingPanel(128), + NSWindowStyleMaskHUDWindow(8192); + + final int value; + const NSWindowStyleMask(this.value); + + static NSWindowStyleMask fromValue(int value) => switch (value) { + 0 => NSWindowStyleMaskBorderless, + 1 => NSWindowStyleMaskTitled, + 2 => NSWindowStyleMaskClosable, + 4 => NSWindowStyleMaskMiniaturizable, + 8 => NSWindowStyleMaskResizable, + 256 => NSWindowStyleMaskTexturedBackground, + 4096 => NSWindowStyleMaskUnifiedTitleAndToolbar, + 16384 => NSWindowStyleMaskFullScreen, + 32768 => NSWindowStyleMaskFullSizeContentView, + 16 => NSWindowStyleMaskUtilityWindow, + 64 => NSWindowStyleMaskDocModalWindow, + 128 => NSWindowStyleMaskNonactivatingPanel, + 8192 => NSWindowStyleMaskHUDWindow, + _ => throw ArgumentError("Unknown value for NSWindowStyleMask: $value"), + }; +} + +late final _sel_frameRectForContentRect_styleMask_ = + objc.registerName("frameRectForContentRect:styleMask:"); +final _objc_msgSend_6 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer, CGRect, ffi.UnsignedLong)>>() + .asFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer, CGRect, int)>(); +final _objc_msgSend_6Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGRect, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGRect, int)>(); +late final _sel_contentRectForFrameRect_styleMask_ = + objc.registerName("contentRectForFrameRect:styleMask:"); +late final _sel_minFrameWidthWithTitle_styleMask_ = + objc.registerName("minFrameWidthWithTitle:styleMask:"); +final _objc_msgSend_7 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +final _objc_msgSend_7Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + double Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); + +enum NSWindowDepth { + NSWindowDepthTwentyfourBitRGB(520), + NSWindowDepthSixtyfourBitRGB(528), + NSWindowDepthOnehundredtwentyeightBitRGB(544); + + final int value; + const NSWindowDepth(this.value); + + static NSWindowDepth fromValue(int value) => switch (value) { + 520 => NSWindowDepthTwentyfourBitRGB, + 528 => NSWindowDepthSixtyfourBitRGB, + 544 => NSWindowDepthOnehundredtwentyeightBitRGB, + _ => throw ArgumentError("Unknown value for NSWindowDepth: $value"), + }; +} + +late final _sel_defaultDepthLimit = objc.registerName("defaultDepthLimit"); +final _objc_msgSend_8 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Int32 Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_frameRectForContentRect_ = + objc.registerName("frameRectForContentRect:"); +final _objc_msgSend_9 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +final _objc_msgSend_9Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_contentRectForFrameRect_ = + objc.registerName("contentRectForFrameRect:"); +typedef instancetype = ffi.Pointer; +typedef Dartinstancetype = objc.ObjCObjectBase; + +enum NSBackingStoreType { + NSBackingStoreRetained(0), + NSBackingStoreNonretained(1), + NSBackingStoreBuffered(2); + + final int value; + const NSBackingStoreType(this.value); + + static NSBackingStoreType fromValue(int value) => switch (value) { + 0 => NSBackingStoreRetained, + 1 => NSBackingStoreNonretained, + 2 => NSBackingStoreBuffered, + _ => + throw ArgumentError("Unknown value for NSBackingStoreType: $value"), + }; +} + +late final _sel_initWithContentRect_styleMask_backing_defer_ = + objc.registerName("initWithContentRect:styleMask:backing:defer:"); +final _objc_msgSend_10 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.UnsignedLong, + ffi.UnsignedLong, + ffi.Bool)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, CGRect, int, int, bool)>(); + +/// NSScreen +class NSScreen extends objc.ObjCObjectBase { + NSScreen._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSScreen] that points to the same underlying object as [other]. + NSScreen.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSScreen] that wraps the given raw object pointer. + NSScreen.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSScreen]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSScreen); + } +} + +late final _class_NSScreen = objc.getClass("NSScreen"); +final _objc_msgSend_0 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isKindOfClass_ = objc.registerName("isKindOfClass:"); +late final _sel_initWithContentRect_styleMask_backing_defer_screen_ = + objc.registerName("initWithContentRect:styleMask:backing:defer:screen:"); +final _objc_msgSend_11 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.UnsignedLong, + ffi.UnsignedLong, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + int, + int, + bool, + ffi.Pointer)>(); +late final _sel_initWithCoder_ = objc.registerName("initWithCoder:"); +final _objc_msgSend_12 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_title = objc.registerName("title"); +final _objc_msgSend_13 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setTitle_ = objc.registerName("setTitle:"); +final _objc_msgSend_14 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_subtitle = objc.registerName("subtitle"); +late final _sel_setSubtitle_ = objc.registerName("setSubtitle:"); + +/// ! +/// @typedef NSWindowTitleVisibility +/// +/// @const NSWindowTitleVisible The default mode has a normal window title and titlebar buttons. +/// @const NSWindowTitleHidden The always hidden mode hides the title and moves the toolbar up into the area previously occupied by the title. +enum NSWindowTitleVisibility { + NSWindowTitleVisible(0), + NSWindowTitleHidden(1); + + final int value; + const NSWindowTitleVisibility(this.value); + + static NSWindowTitleVisibility fromValue(int value) => switch (value) { + 0 => NSWindowTitleVisible, + 1 => NSWindowTitleHidden, + _ => throw ArgumentError( + "Unknown value for NSWindowTitleVisibility: $value"), + }; +} + +late final _sel_titleVisibility = objc.registerName("titleVisibility"); +final _objc_msgSend_15 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setTitleVisibility_ = objc.registerName("setTitleVisibility:"); +final _objc_msgSend_16 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_titlebarAppearsTransparent = + objc.registerName("titlebarAppearsTransparent"); +final _objc_msgSend_17 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setTitlebarAppearsTransparent_ = + objc.registerName("setTitlebarAppearsTransparent:"); +final _objc_msgSend_18 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, bool)>(); + +/// ! +/// @typedef NSWindowToolbarStyle +/// +/// @const NSWindowToolbarStyleAutomatic The default value. The style will be determined by the window's given configuration. +/// @const NSWindowToolbarStyleExpanded The toolbar will appear below the window title. +/// @const NSWindowToolbarStylePreference The toolbar will appear below the window title and the items in the toolbar will attempt to have equal widths when possible. +/// @const NSWindowToolbarStyleUnified The window title will appear inline with the toolbar when visible. +/// @const NSWindowToolbarStyleUnifiedCompact Same as \c NSWindowToolbarStyleUnified, but with reduced margins in the toolbar allowing more focus to be on the contents of the window. +enum NSWindowToolbarStyle { + NSWindowToolbarStyleAutomatic(0), + NSWindowToolbarStyleExpanded(1), + NSWindowToolbarStylePreference(2), + NSWindowToolbarStyleUnified(3), + NSWindowToolbarStyleUnifiedCompact(4); + + final int value; + const NSWindowToolbarStyle(this.value); + + static NSWindowToolbarStyle fromValue(int value) => switch (value) { + 0 => NSWindowToolbarStyleAutomatic, + 1 => NSWindowToolbarStyleExpanded, + 2 => NSWindowToolbarStylePreference, + 3 => NSWindowToolbarStyleUnified, + 4 => NSWindowToolbarStyleUnifiedCompact, + _ => + throw ArgumentError("Unknown value for NSWindowToolbarStyle: $value"), + }; +} + +late final _sel_toolbarStyle = objc.registerName("toolbarStyle"); +final _objc_msgSend_19 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setToolbarStyle_ = objc.registerName("setToolbarStyle:"); +final _objc_msgSend_20 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_contentLayoutRect = objc.registerName("contentLayoutRect"); +final _objc_msgSend_21 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGRect Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_21Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); +late final _sel_contentLayoutGuide = objc.registerName("contentLayoutGuide"); +late final _sel_titlebarAccessoryViewControllers = + objc.registerName("titlebarAccessoryViewControllers"); +final _objc_msgSend_22 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setTitlebarAccessoryViewControllers_ = + objc.registerName("setTitlebarAccessoryViewControllers:"); +final _objc_msgSend_23 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// NSTitlebarAccessoryViewController +class NSTitlebarAccessoryViewController extends objc.ObjCObjectBase { + NSTitlebarAccessoryViewController._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSTitlebarAccessoryViewController] that points to the same underlying object as [other]. + NSTitlebarAccessoryViewController.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSTitlebarAccessoryViewController] that wraps the given raw object pointer. + NSTitlebarAccessoryViewController.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSTitlebarAccessoryViewController]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, + _class_NSTitlebarAccessoryViewController); + } +} + +late final _class_NSTitlebarAccessoryViewController = + objc.getClass("NSTitlebarAccessoryViewController"); +late final _sel_addTitlebarAccessoryViewController_ = + objc.registerName("addTitlebarAccessoryViewController:"); +final _objc_msgSend_24 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_insertTitlebarAccessoryViewController_atIndex_ = + objc.registerName("insertTitlebarAccessoryViewController:atIndex:"); +final _objc_msgSend_25 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Long)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_removeTitlebarAccessoryViewControllerAtIndex_ = + objc.registerName("removeTitlebarAccessoryViewControllerAtIndex:"); +final _objc_msgSend_26 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_representedURL = objc.registerName("representedURL"); +final _objc_msgSend_27 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setRepresentedURL_ = objc.registerName("setRepresentedURL:"); +final _objc_msgSend_28 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_representedFilename = objc.registerName("representedFilename"); +late final _sel_setRepresentedFilename_ = + objc.registerName("setRepresentedFilename:"); +late final _sel_setTitleWithRepresentedFilename_ = + objc.registerName("setTitleWithRepresentedFilename:"); +final _objc_msgSend_29 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isExcludedFromWindowsMenu = + objc.registerName("isExcludedFromWindowsMenu"); +late final _sel_setExcludedFromWindowsMenu_ = + objc.registerName("setExcludedFromWindowsMenu:"); + +/// NSView +class NSView extends NSResponder { + NSView._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSView] that points to the same underlying object as [other]. + NSView.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSView] that wraps the given raw object pointer. + NSView.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSView]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSView); + } + + /// initWithFrame: + NSView initWithFrame_(CGRect frameRect) { + final _ret = _objc_msgSend_30(this.pointer, _sel_initWithFrame_, frameRect); + return NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + NSView? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_31(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// window + NSWindow? get window { + final _ret = _objc_msgSend_32(this.pointer, _sel_window); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// superview + NSView? get superview { + final _ret = _objc_msgSend_33(this.pointer, _sel_superview); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// subviews + objc.ObjCObjectBase get subviews { + final _ret = _objc_msgSend_34(this.pointer, _sel_subviews); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setSubviews: + set subviews(objc.ObjCObjectBase value) { + return _objc_msgSend_35(this.pointer, _sel_setSubviews_, value.pointer); + } + + /// isDescendantOf: + bool isDescendantOf_(NSView view) { + return _objc_msgSend_36(this.pointer, _sel_isDescendantOf_, view.pointer); + } + + /// ancestorSharedWithView: + NSView? ancestorSharedWithView_(NSView view) { + final _ret = _objc_msgSend_37( + this.pointer, _sel_ancestorSharedWithView_, view.pointer); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// opaqueAncestor + NSView? get opaqueAncestor { + final _ret = _objc_msgSend_33(this.pointer, _sel_opaqueAncestor); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// isHidden + bool get hidden { + return _objc_msgSend_17(this.pointer, _sel_isHidden); + } + + /// setHidden: + set hidden(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setHidden_, value); + } + + /// isHiddenOrHasHiddenAncestor + bool get hiddenOrHasHiddenAncestor { + return _objc_msgSend_17(this.pointer, _sel_isHiddenOrHasHiddenAncestor); + } + + /// getRectsBeingDrawn:count: + void getRectsBeingDrawn_count_( + ffi.Pointer> rects, ffi.Pointer count) { + _objc_msgSend_38( + this.pointer, _sel_getRectsBeingDrawn_count_, rects, count); + } + + /// needsToDrawRect: + bool needsToDrawRect_(CGRect rect) { + return _objc_msgSend_39(this.pointer, _sel_needsToDrawRect_, rect); + } + + /// wantsDefaultClipping + bool get wantsDefaultClipping { + return _objc_msgSend_17(this.pointer, _sel_wantsDefaultClipping); + } + + /// viewDidHide + void viewDidHide() { + _objc_msgSend_5(this.pointer, _sel_viewDidHide); + } + + /// viewDidUnhide + void viewDidUnhide() { + _objc_msgSend_5(this.pointer, _sel_viewDidUnhide); + } + + /// addSubview: + void addSubview_(NSView view) { + _objc_msgSend_40(this.pointer, _sel_addSubview_, view.pointer); + } + + /// addSubview:positioned:relativeTo: + void addSubview_positioned_relativeTo_( + NSView view, NSWindowOrderingMode place, NSView? otherView) { + _objc_msgSend_41(this.pointer, _sel_addSubview_positioned_relativeTo_, + view.pointer, place.value, otherView?.pointer ?? ffi.nullptr); + } + + /// sortSubviewsUsingFunction:context: + void sortSubviewsUsingFunction_context_( + ffi.Pointer< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>> + compare, + ffi.Pointer context) { + _objc_msgSend_42(this.pointer, _sel_sortSubviewsUsingFunction_context_, + compare, context); + } + + /// viewWillMoveToWindow: + void viewWillMoveToWindow_(NSWindow? newWindow) { + _objc_msgSend_43(this.pointer, _sel_viewWillMoveToWindow_, + newWindow?.pointer ?? ffi.nullptr); + } + + /// viewDidMoveToWindow + void viewDidMoveToWindow() { + _objc_msgSend_5(this.pointer, _sel_viewDidMoveToWindow); + } + + /// viewWillMoveToSuperview: + void viewWillMoveToSuperview_(NSView? newSuperview) { + _objc_msgSend_44(this.pointer, _sel_viewWillMoveToSuperview_, + newSuperview?.pointer ?? ffi.nullptr); + } + + /// viewDidMoveToSuperview + void viewDidMoveToSuperview() { + _objc_msgSend_5(this.pointer, _sel_viewDidMoveToSuperview); + } + + /// didAddSubview: + void didAddSubview_(NSView subview) { + _objc_msgSend_40(this.pointer, _sel_didAddSubview_, subview.pointer); + } + + /// willRemoveSubview: + void willRemoveSubview_(NSView subview) { + _objc_msgSend_40(this.pointer, _sel_willRemoveSubview_, subview.pointer); + } + + /// removeFromSuperview + void removeFromSuperview() { + _objc_msgSend_5(this.pointer, _sel_removeFromSuperview); + } + + /// replaceSubview:with: + void replaceSubview_with_(NSView oldView, NSView newView) { + _objc_msgSend_45(this.pointer, _sel_replaceSubview_with_, oldView.pointer, + newView.pointer); + } + + /// removeFromSuperviewWithoutNeedingDisplay + void removeFromSuperviewWithoutNeedingDisplay() { + _objc_msgSend_5( + this.pointer, _sel_removeFromSuperviewWithoutNeedingDisplay); + } + + /// viewDidChangeBackingProperties + void viewDidChangeBackingProperties() { + _objc_msgSend_5(this.pointer, _sel_viewDidChangeBackingProperties); + } + + /// postsFrameChangedNotifications + bool get postsFrameChangedNotifications { + return _objc_msgSend_17(this.pointer, _sel_postsFrameChangedNotifications); + } + + /// setPostsFrameChangedNotifications: + set postsFrameChangedNotifications(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setPostsFrameChangedNotifications_, value); + } + + /// resizeSubviewsWithOldSize: + void resizeSubviewsWithOldSize_(CGSize oldSize) { + _objc_msgSend_46(this.pointer, _sel_resizeSubviewsWithOldSize_, oldSize); + } + + /// resizeWithOldSuperviewSize: + void resizeWithOldSuperviewSize_(CGSize oldSize) { + _objc_msgSend_46(this.pointer, _sel_resizeWithOldSuperviewSize_, oldSize); + } + + /// autoresizesSubviews + bool get autoresizesSubviews { + return _objc_msgSend_17(this.pointer, _sel_autoresizesSubviews); + } + + /// setAutoresizesSubviews: + set autoresizesSubviews(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setAutoresizesSubviews_, value); + } + + /// autoresizingMask + NSAutoresizingMaskOptions get autoresizingMask { + final _ret = _objc_msgSend_47(this.pointer, _sel_autoresizingMask); + return NSAutoresizingMaskOptions.fromValue(_ret); + } + + /// setAutoresizingMask: + set autoresizingMask(NSAutoresizingMaskOptions value) { + return _objc_msgSend_48( + this.pointer, _sel_setAutoresizingMask_, value.value); + } + + /// setFrameOrigin: + void setFrameOrigin_(CGPoint newOrigin) { + _objc_msgSend_49(this.pointer, _sel_setFrameOrigin_, newOrigin); + } + + /// setFrameSize: + void setFrameSize_(CGSize newSize) { + _objc_msgSend_46(this.pointer, _sel_setFrameSize_, newSize); + } + + /// frame + void getFrame(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_21Stret(stret, this.pointer, _sel_frame) + : stret.ref = _objc_msgSend_21(this.pointer, _sel_frame); + } + + /// setFrame: + set frame(CGRect value) { + return _objc_msgSend_50(this.pointer, _sel_setFrame_, value); + } + + /// frameRotation + double get frameRotation { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_frameRotation) + : _objc_msgSend_51(this.pointer, _sel_frameRotation); + } + + /// setFrameRotation: + set frameRotation(double value) { + return _objc_msgSend_52(this.pointer, _sel_setFrameRotation_, value); + } + + /// frameCenterRotation + double get frameCenterRotation { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_frameCenterRotation) + : _objc_msgSend_51(this.pointer, _sel_frameCenterRotation); + } + + /// setFrameCenterRotation: + set frameCenterRotation(double value) { + return _objc_msgSend_52(this.pointer, _sel_setFrameCenterRotation_, value); + } + + /// setBoundsOrigin: + void setBoundsOrigin_(CGPoint newOrigin) { + _objc_msgSend_49(this.pointer, _sel_setBoundsOrigin_, newOrigin); + } + + /// setBoundsSize: + void setBoundsSize_(CGSize newSize) { + _objc_msgSend_46(this.pointer, _sel_setBoundsSize_, newSize); + } + + /// boundsRotation + double get boundsRotation { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_boundsRotation) + : _objc_msgSend_51(this.pointer, _sel_boundsRotation); + } + + /// setBoundsRotation: + set boundsRotation(double value) { + return _objc_msgSend_52(this.pointer, _sel_setBoundsRotation_, value); + } + + /// translateOriginToPoint: + void translateOriginToPoint_(CGPoint translation) { + _objc_msgSend_49(this.pointer, _sel_translateOriginToPoint_, translation); + } + + /// scaleUnitSquareToSize: + void scaleUnitSquareToSize_(CGSize newUnitSize) { + _objc_msgSend_46(this.pointer, _sel_scaleUnitSquareToSize_, newUnitSize); + } + + /// rotateByAngle: + void rotateByAngle_(double angle) { + _objc_msgSend_53(this.pointer, _sel_rotateByAngle_, angle); + } + + /// bounds + void getBounds(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_21Stret(stret, this.pointer, _sel_bounds) + : stret.ref = _objc_msgSend_21(this.pointer, _sel_bounds); + } + + /// setBounds: + set bounds(CGRect value) { + return _objc_msgSend_50(this.pointer, _sel_setBounds_, value); + } + + /// isFlipped + bool get flipped { + return _objc_msgSend_17(this.pointer, _sel_isFlipped); + } + + /// isRotatedFromBase + bool get rotatedFromBase { + return _objc_msgSend_17(this.pointer, _sel_isRotatedFromBase); + } + + /// isRotatedOrScaledFromBase + bool get rotatedOrScaledFromBase { + return _objc_msgSend_17(this.pointer, _sel_isRotatedOrScaledFromBase); + } + + /// isOpaque + bool get opaque { + return _objc_msgSend_17(this.pointer, _sel_isOpaque); + } + + /// convertPoint:fromView: + void convertPoint_fromView_( + ffi.Pointer stret, CGPoint point, NSView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_54Stret(stret, this.pointer, + _sel_convertPoint_fromView_, point, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_54(this.pointer, + _sel_convertPoint_fromView_, point, view?.pointer ?? ffi.nullptr); + } + + /// convertPoint:toView: + void convertPoint_toView_( + ffi.Pointer stret, CGPoint point, NSView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_54Stret(stret, this.pointer, _sel_convertPoint_toView_, + point, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_54(this.pointer, _sel_convertPoint_toView_, + point, view?.pointer ?? ffi.nullptr); + } + + /// convertSize:fromView: + void convertSize_fromView_( + ffi.Pointer stret, CGSize size, NSView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_55Stret(stret, this.pointer, _sel_convertSize_fromView_, + size, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_55(this.pointer, _sel_convertSize_fromView_, + size, view?.pointer ?? ffi.nullptr); + } + + /// convertSize:toView: + void convertSize_toView_( + ffi.Pointer stret, CGSize size, NSView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_55Stret(stret, this.pointer, _sel_convertSize_toView_, + size, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_55(this.pointer, _sel_convertSize_toView_, + size, view?.pointer ?? ffi.nullptr); + } + + /// convertRect:fromView: + void convertRect_fromView_( + ffi.Pointer stret, CGRect rect, NSView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_56Stret(stret, this.pointer, _sel_convertRect_fromView_, + rect, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_56(this.pointer, _sel_convertRect_fromView_, + rect, view?.pointer ?? ffi.nullptr); + } + + /// convertRect:toView: + void convertRect_toView_( + ffi.Pointer stret, CGRect rect, NSView? view) { + objc.useMsgSendVariants + ? _objc_msgSend_56Stret(stret, this.pointer, _sel_convertRect_toView_, + rect, view?.pointer ?? ffi.nullptr) + : stret.ref = _objc_msgSend_56(this.pointer, _sel_convertRect_toView_, + rect, view?.pointer ?? ffi.nullptr); + } + + /// backingAlignedRect:options: + void backingAlignedRect_options_( + ffi.Pointer stret, CGRect rect, NSAlignmentOptions options) { + objc.useMsgSendVariants + ? _objc_msgSend_57Stret(stret, this.pointer, + _sel_backingAlignedRect_options_, rect, options.value) + : stret.ref = _objc_msgSend_57(this.pointer, + _sel_backingAlignedRect_options_, rect, options.value); + } + + /// centerScanRect: + void centerScanRect_(ffi.Pointer stret, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret(stret, this.pointer, _sel_centerScanRect_, rect) + : stret.ref = _objc_msgSend_9(this.pointer, _sel_centerScanRect_, rect); + } + + /// convertPointToBacking: + void convertPointToBacking_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertPointToBacking_, point) + : stret.ref = + _objc_msgSend_58(this.pointer, _sel_convertPointToBacking_, point); + } + + /// convertPointFromBacking: + void convertPointFromBacking_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertPointFromBacking_, point) + : stret.ref = _objc_msgSend_58( + this.pointer, _sel_convertPointFromBacking_, point); + } + + /// convertSizeToBacking: + void convertSizeToBacking_(ffi.Pointer stret, CGSize size) { + objc.useMsgSendVariants + ? _objc_msgSend_59Stret( + stret, this.pointer, _sel_convertSizeToBacking_, size) + : stret.ref = + _objc_msgSend_59(this.pointer, _sel_convertSizeToBacking_, size); + } + + /// convertSizeFromBacking: + void convertSizeFromBacking_(ffi.Pointer stret, CGSize size) { + objc.useMsgSendVariants + ? _objc_msgSend_59Stret( + stret, this.pointer, _sel_convertSizeFromBacking_, size) + : stret.ref = + _objc_msgSend_59(this.pointer, _sel_convertSizeFromBacking_, size); + } + + /// convertRectToBacking: + void convertRectToBacking_(ffi.Pointer stret, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_convertRectToBacking_, rect) + : stret.ref = + _objc_msgSend_9(this.pointer, _sel_convertRectToBacking_, rect); + } + + /// convertRectFromBacking: + void convertRectFromBacking_(ffi.Pointer stret, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_convertRectFromBacking_, rect) + : stret.ref = + _objc_msgSend_9(this.pointer, _sel_convertRectFromBacking_, rect); + } + + /// convertPointToLayer: + void convertPointToLayer_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertPointToLayer_, point) + : stret.ref = + _objc_msgSend_58(this.pointer, _sel_convertPointToLayer_, point); + } + + /// convertPointFromLayer: + void convertPointFromLayer_(ffi.Pointer stret, CGPoint point) { + objc.useMsgSendVariants + ? _objc_msgSend_58Stret( + stret, this.pointer, _sel_convertPointFromLayer_, point) + : stret.ref = + _objc_msgSend_58(this.pointer, _sel_convertPointFromLayer_, point); + } + + /// convertSizeToLayer: + void convertSizeToLayer_(ffi.Pointer stret, CGSize size) { + objc.useMsgSendVariants + ? _objc_msgSend_59Stret( + stret, this.pointer, _sel_convertSizeToLayer_, size) + : stret.ref = + _objc_msgSend_59(this.pointer, _sel_convertSizeToLayer_, size); + } + + /// convertSizeFromLayer: + void convertSizeFromLayer_(ffi.Pointer stret, CGSize size) { + objc.useMsgSendVariants + ? _objc_msgSend_59Stret( + stret, this.pointer, _sel_convertSizeFromLayer_, size) + : stret.ref = + _objc_msgSend_59(this.pointer, _sel_convertSizeFromLayer_, size); + } + + /// convertRectToLayer: + void convertRectToLayer_(ffi.Pointer stret, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_convertRectToLayer_, rect) + : stret.ref = + _objc_msgSend_9(this.pointer, _sel_convertRectToLayer_, rect); + } + + /// convertRectFromLayer: + void convertRectFromLayer_(ffi.Pointer stret, CGRect rect) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_convertRectFromLayer_, rect) + : stret.ref = + _objc_msgSend_9(this.pointer, _sel_convertRectFromLayer_, rect); + } + + /// canDrawConcurrently + bool get canDrawConcurrently { + return _objc_msgSend_17(this.pointer, _sel_canDrawConcurrently); + } + + /// setCanDrawConcurrently: + set canDrawConcurrently(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setCanDrawConcurrently_, value); + } + + /// canDraw + bool get canDraw { + return _objc_msgSend_17(this.pointer, _sel_canDraw); + } + + /// setNeedsDisplayInRect: + void setNeedsDisplayInRect_(CGRect invalidRect) { + _objc_msgSend_60(this.pointer, _sel_setNeedsDisplayInRect_, invalidRect); + } + + /// needsDisplay + bool get needsDisplay { + return _objc_msgSend_17(this.pointer, _sel_needsDisplay); + } + + /// setNeedsDisplay: + set needsDisplay(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setNeedsDisplay_, value); + } + + /// lockFocus + void lockFocus() { + _objc_msgSend_5(this.pointer, _sel_lockFocus); + } + + /// unlockFocus + void unlockFocus() { + _objc_msgSend_5(this.pointer, _sel_unlockFocus); + } + + /// lockFocusIfCanDraw + bool lockFocusIfCanDraw() { + return _objc_msgSend_17(this.pointer, _sel_lockFocusIfCanDraw); + } + + /// lockFocusIfCanDrawInContext: + bool lockFocusIfCanDrawInContext_(NSGraphicsContext context) { + return _objc_msgSend_61( + this.pointer, _sel_lockFocusIfCanDrawInContext_, context.pointer); + } + + /// focusView + static NSView? getFocusView() { + final _ret = _objc_msgSend_33(_class_NSView, _sel_focusView); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// visibleRect + void getVisibleRect(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_21Stret(stret, this.pointer, _sel_visibleRect) + : stret.ref = _objc_msgSend_21(this.pointer, _sel_visibleRect); + } + + /// display + void display() { + _objc_msgSend_5(this.pointer, _sel_display); + } + + /// displayIfNeeded + void displayIfNeeded() { + _objc_msgSend_5(this.pointer, _sel_displayIfNeeded); + } + + /// displayIfNeededIgnoringOpacity + void displayIfNeededIgnoringOpacity() { + _objc_msgSend_5(this.pointer, _sel_displayIfNeededIgnoringOpacity); + } + + /// displayRect: + void displayRect_(CGRect rect) { + _objc_msgSend_60(this.pointer, _sel_displayRect_, rect); + } + + /// displayIfNeededInRect: + void displayIfNeededInRect_(CGRect rect) { + _objc_msgSend_60(this.pointer, _sel_displayIfNeededInRect_, rect); + } + + /// displayRectIgnoringOpacity: + void displayRectIgnoringOpacity_(CGRect rect) { + _objc_msgSend_60(this.pointer, _sel_displayRectIgnoringOpacity_, rect); + } + + /// displayIfNeededInRectIgnoringOpacity: + void displayIfNeededInRectIgnoringOpacity_(CGRect rect) { + _objc_msgSend_60( + this.pointer, _sel_displayIfNeededInRectIgnoringOpacity_, rect); + } + + /// drawRect: + void drawRect_(CGRect dirtyRect) { + _objc_msgSend_60(this.pointer, _sel_drawRect_, dirtyRect); + } + + /// displayRectIgnoringOpacity:inContext: + void displayRectIgnoringOpacity_inContext_( + CGRect rect, NSGraphicsContext context) { + _objc_msgSend_62(this.pointer, _sel_displayRectIgnoringOpacity_inContext_, + rect, context.pointer); + } + + /// bitmapImageRepForCachingDisplayInRect: + NSBitmapImageRep? bitmapImageRepForCachingDisplayInRect_(CGRect rect) { + final _ret = _objc_msgSend_63( + this.pointer, _sel_bitmapImageRepForCachingDisplayInRect_, rect); + return _ret.address == 0 + ? null + : NSBitmapImageRep.castFromPointer(_ret, retain: true, release: true); + } + + /// cacheDisplayInRect:toBitmapImageRep: + void cacheDisplayInRect_toBitmapImageRep_( + CGRect rect, NSBitmapImageRep bitmapImageRep) { + _objc_msgSend_64(this.pointer, _sel_cacheDisplayInRect_toBitmapImageRep_, + rect, bitmapImageRep.pointer); + } + + /// viewWillDraw + void viewWillDraw() { + _objc_msgSend_5(this.pointer, _sel_viewWillDraw); + } + + /// scrollPoint: + void scrollPoint_(CGPoint point) { + _objc_msgSend_49(this.pointer, _sel_scrollPoint_, point); + } + + /// scrollRectToVisible: + bool scrollRectToVisible_(CGRect rect) { + return _objc_msgSend_39(this.pointer, _sel_scrollRectToVisible_, rect); + } + + /// autoscroll: + bool autoscroll_(NSEvent event) { + return _objc_msgSend_102(this.pointer, _sel_autoscroll_, event.pointer); + } + + /// adjustScroll: + void adjustScroll_(ffi.Pointer stret, CGRect newVisible) { + objc.useMsgSendVariants + ? _objc_msgSend_9Stret( + stret, this.pointer, _sel_adjustScroll_, newVisible) + : stret.ref = + _objc_msgSend_9(this.pointer, _sel_adjustScroll_, newVisible); + } + + /// scrollRect:by: + void scrollRect_by_(CGRect rect, CGSize delta) { + _objc_msgSend_103(this.pointer, _sel_scrollRect_by_, rect, delta); + } + + /// translateRectsNeedingDisplayInRect:by: + void translateRectsNeedingDisplayInRect_by_(CGRect clipRect, CGSize delta) { + _objc_msgSend_103(this.pointer, _sel_translateRectsNeedingDisplayInRect_by_, + clipRect, delta); + } + + /// hitTest: + NSView? hitTest_(CGPoint point) { + final _ret = _objc_msgSend_104(this.pointer, _sel_hitTest_, point); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// mouse:inRect: + bool mouse_inRect_(CGPoint point, CGRect rect) { + return _objc_msgSend_105(this.pointer, _sel_mouse_inRect_, point, rect); + } + + /// viewWithTag: + NSView? viewWithTag_(int tag) { + final _ret = _objc_msgSend_106(this.pointer, _sel_viewWithTag_, tag); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// tag + int get tag { + return _objc_msgSend_67(this.pointer, _sel_tag); + } + + /// performKeyEquivalent: + bool performKeyEquivalent_(NSEvent event) { + return _objc_msgSend_102( + this.pointer, _sel_performKeyEquivalent_, event.pointer); + } + + /// acceptsFirstMouse: + bool acceptsFirstMouse_(NSEvent? event) { + return _objc_msgSend_107( + this.pointer, _sel_acceptsFirstMouse_, event?.pointer ?? ffi.nullptr); + } + + /// shouldDelayWindowOrderingForEvent: + bool shouldDelayWindowOrderingForEvent_(NSEvent event) { + return _objc_msgSend_102( + this.pointer, _sel_shouldDelayWindowOrderingForEvent_, event.pointer); + } + + /// needsPanelToBecomeKey + bool get needsPanelToBecomeKey { + return _objc_msgSend_17(this.pointer, _sel_needsPanelToBecomeKey); + } + + /// mouseDownCanMoveWindow + bool get mouseDownCanMoveWindow { + return _objc_msgSend_17(this.pointer, _sel_mouseDownCanMoveWindow); + } + + /// acceptsTouchEvents + bool get acceptsTouchEvents { + return _objc_msgSend_17(this.pointer, _sel_acceptsTouchEvents); + } + + /// setAcceptsTouchEvents: + set acceptsTouchEvents(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setAcceptsTouchEvents_, value); + } + + /// wantsRestingTouches + bool get wantsRestingTouches { + return _objc_msgSend_17(this.pointer, _sel_wantsRestingTouches); + } + + /// setWantsRestingTouches: + set wantsRestingTouches(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setWantsRestingTouches_, value); + } + + /// makeBackingLayer + CALayer makeBackingLayer() { + final _ret = _objc_msgSend_108(this.pointer, _sel_makeBackingLayer); + return CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// layerContentsRedrawPolicy + NSViewLayerContentsRedrawPolicy get layerContentsRedrawPolicy { + final _ret = + _objc_msgSend_109(this.pointer, _sel_layerContentsRedrawPolicy); + return NSViewLayerContentsRedrawPolicy.fromValue(_ret); + } + + /// setLayerContentsRedrawPolicy: + set layerContentsRedrawPolicy(NSViewLayerContentsRedrawPolicy value) { + return _objc_msgSend_110( + this.pointer, _sel_setLayerContentsRedrawPolicy_, value.value); + } + + /// layerContentsPlacement + NSViewLayerContentsPlacement get layerContentsPlacement { + final _ret = _objc_msgSend_111(this.pointer, _sel_layerContentsPlacement); + return NSViewLayerContentsPlacement.fromValue(_ret); + } + + /// setLayerContentsPlacement: + set layerContentsPlacement(NSViewLayerContentsPlacement value) { + return _objc_msgSend_112( + this.pointer, _sel_setLayerContentsPlacement_, value.value); + } + + /// wantsLayer + bool get wantsLayer { + return _objc_msgSend_17(this.pointer, _sel_wantsLayer); + } + + /// setWantsLayer: + set wantsLayer(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setWantsLayer_, value); + } + + /// layer + CALayer? get layer { + final _ret = _objc_msgSend_113(this.pointer, _sel_layer); + return _ret.address == 0 + ? null + : CALayer.castFromPointer(_ret, retain: true, release: true); + } + + /// setLayer: + set layer(CALayer? value) { + return _objc_msgSend_114( + this.pointer, _sel_setLayer_, value?.pointer ?? ffi.nullptr); + } + + /// wantsUpdateLayer + bool get wantsUpdateLayer { + return _objc_msgSend_17(this.pointer, _sel_wantsUpdateLayer); + } + + /// updateLayer + void updateLayer() { + _objc_msgSend_5(this.pointer, _sel_updateLayer); + } + + /// canDrawSubviewsIntoLayer + bool get canDrawSubviewsIntoLayer { + return _objc_msgSend_17(this.pointer, _sel_canDrawSubviewsIntoLayer); + } + + /// setCanDrawSubviewsIntoLayer: + set canDrawSubviewsIntoLayer(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setCanDrawSubviewsIntoLayer_, value); + } + + /// layoutSubtreeIfNeeded + void layoutSubtreeIfNeeded() { + _objc_msgSend_5(this.pointer, _sel_layoutSubtreeIfNeeded); + } + + /// layout + void layout() { + _objc_msgSend_5(this.pointer, _sel_layout); + } + + /// needsLayout + bool get needsLayout { + return _objc_msgSend_17(this.pointer, _sel_needsLayout); + } + + /// setNeedsLayout: + set needsLayout(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setNeedsLayout_, value); + } + + /// alphaValue + double get alphaValue { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_alphaValue) + : _objc_msgSend_51(this.pointer, _sel_alphaValue); + } + + /// setAlphaValue: + set alphaValue(double value) { + return _objc_msgSend_52(this.pointer, _sel_setAlphaValue_, value); + } + + /// layerUsesCoreImageFilters + bool get layerUsesCoreImageFilters { + return _objc_msgSend_17(this.pointer, _sel_layerUsesCoreImageFilters); + } + + /// setLayerUsesCoreImageFilters: + set layerUsesCoreImageFilters(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setLayerUsesCoreImageFilters_, value); + } + + /// backgroundFilters + objc.ObjCObjectBase get backgroundFilters { + final _ret = _objc_msgSend_34(this.pointer, _sel_backgroundFilters); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setBackgroundFilters: + set backgroundFilters(objc.ObjCObjectBase value) { + return _objc_msgSend_35( + this.pointer, _sel_setBackgroundFilters_, value.pointer); + } + + /// compositingFilter + CIFilter? get compositingFilter { + final _ret = _objc_msgSend_115(this.pointer, _sel_compositingFilter); + return _ret.address == 0 + ? null + : CIFilter.castFromPointer(_ret, retain: true, release: true); + } + + /// setCompositingFilter: + set compositingFilter(CIFilter? value) { + return _objc_msgSend_116(this.pointer, _sel_setCompositingFilter_, + value?.pointer ?? ffi.nullptr); + } + + /// contentFilters + objc.ObjCObjectBase get contentFilters { + final _ret = _objc_msgSend_34(this.pointer, _sel_contentFilters); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setContentFilters: + set contentFilters(objc.ObjCObjectBase value) { + return _objc_msgSend_35( + this.pointer, _sel_setContentFilters_, value.pointer); + } + + /// shadow + NSShadow? get shadow { + final _ret = _objc_msgSend_117(this.pointer, _sel_shadow); + return _ret.address == 0 + ? null + : NSShadow.castFromPointer(_ret, retain: true, release: true); + } + + /// setShadow: + set shadow(NSShadow? value) { + return _objc_msgSend_118( + this.pointer, _sel_setShadow_, value?.pointer ?? ffi.nullptr); + } + + /// clipsToBounds + bool get clipsToBounds { + return _objc_msgSend_17(this.pointer, _sel_clipsToBounds); + } + + /// setClipsToBounds: + set clipsToBounds(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setClipsToBounds_, value); + } + + /// postsBoundsChangedNotifications + bool get postsBoundsChangedNotifications { + return _objc_msgSend_17(this.pointer, _sel_postsBoundsChangedNotifications); + } + + /// setPostsBoundsChangedNotifications: + set postsBoundsChangedNotifications(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setPostsBoundsChangedNotifications_, value); + } + + /// enclosingScrollView + NSScrollView? get enclosingScrollView { + final _ret = _objc_msgSend_119(this.pointer, _sel_enclosingScrollView); + return _ret.address == 0 + ? null + : NSScrollView.castFromPointer(_ret, retain: true, release: true); + } + + /// menuForEvent: + NSMenu? menuForEvent_(NSEvent event) { + final _ret = + _objc_msgSend_162(this.pointer, _sel_menuForEvent_, event.pointer); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// defaultMenu + static NSMenu? getDefaultMenu() { + final _ret = _objc_msgSend_125(_class_NSView, _sel_defaultMenu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// willOpenMenu:withEvent: + void willOpenMenu_withEvent_(NSMenu menu, NSEvent event) { + _objc_msgSend_163(this.pointer, _sel_willOpenMenu_withEvent_, menu.pointer, + event.pointer); + } + + /// didCloseMenu:withEvent: + void didCloseMenu_withEvent_(NSMenu menu, NSEvent? event) { + _objc_msgSend_164(this.pointer, _sel_didCloseMenu_withEvent_, menu.pointer, + event?.pointer ?? ffi.nullptr); + } + + /// toolTip + objc.NSString? get toolTip { + final _ret = _objc_msgSend_72(this.pointer, _sel_toolTip); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setToolTip: + set toolTip(objc.NSString? value) { + return _objc_msgSend_140( + this.pointer, _sel_setToolTip_, value?.pointer ?? ffi.nullptr); + } + + /// addToolTipRect:owner:userData: + int addToolTipRect_owner_userData_( + CGRect rect, objc.ObjCObjectBase owner, ffi.Pointer data) { + return _objc_msgSend_165(this.pointer, _sel_addToolTipRect_owner_userData_, + rect, owner.pointer, data); + } + + /// removeToolTip: + void removeToolTip_(int tag) { + _objc_msgSend_26(this.pointer, _sel_removeToolTip_, tag); + } + + /// removeAllToolTips + void removeAllToolTips() { + _objc_msgSend_5(this.pointer, _sel_removeAllToolTips); + } + + /// viewWillStartLiveResize + void viewWillStartLiveResize() { + _objc_msgSend_5(this.pointer, _sel_viewWillStartLiveResize); + } + + /// viewDidEndLiveResize + void viewDidEndLiveResize() { + _objc_msgSend_5(this.pointer, _sel_viewDidEndLiveResize); + } + + /// inLiveResize + bool get inLiveResize { + return _objc_msgSend_17(this.pointer, _sel_inLiveResize); + } + + /// preservesContentDuringLiveResize + bool get preservesContentDuringLiveResize { + return _objc_msgSend_17( + this.pointer, _sel_preservesContentDuringLiveResize); + } + + /// rectPreservedDuringLiveResize + void getRectPreservedDuringLiveResize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_21Stret( + stret, this.pointer, _sel_rectPreservedDuringLiveResize) + : stret.ref = + _objc_msgSend_21(this.pointer, _sel_rectPreservedDuringLiveResize); + } + + /// getRectsExposedDuringLiveResize:count: + void getRectsExposedDuringLiveResize_count_( + ffi.Pointer exposedRects, ffi.Pointer count) { + _objc_msgSend_166(this.pointer, _sel_getRectsExposedDuringLiveResize_count_, + exposedRects, count); + } + + /// inputContext + NSTextInputContext? get inputContext { + final _ret = _objc_msgSend_167(this.pointer, _sel_inputContext); + return _ret.address == 0 + ? null + : NSTextInputContext.castFromPointer(_ret, retain: true, release: true); + } + + /// rectForSmartMagnificationAtPoint:inRect: + void rectForSmartMagnificationAtPoint_inRect_( + ffi.Pointer stret, CGPoint location, CGRect visibleRect) { + objc.useMsgSendVariants + ? _objc_msgSend_168Stret( + stret, + this.pointer, + _sel_rectForSmartMagnificationAtPoint_inRect_, + location, + visibleRect) + : stret.ref = _objc_msgSend_168( + this.pointer, + _sel_rectForSmartMagnificationAtPoint_inRect_, + location, + visibleRect); + } + + /// userInterfaceLayoutDirection + NSUserInterfaceLayoutDirection get userInterfaceLayoutDirection { + final _ret = + _objc_msgSend_160(this.pointer, _sel_userInterfaceLayoutDirection); + return NSUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// setUserInterfaceLayoutDirection: + set userInterfaceLayoutDirection(NSUserInterfaceLayoutDirection value) { + return _objc_msgSend_161( + this.pointer, _sel_setUserInterfaceLayoutDirection_, value.value); + } + + /// prepareForReuse + void prepareForReuse() { + _objc_msgSend_5(this.pointer, _sel_prepareForReuse); + } + + /// isCompatibleWithResponsiveScrolling + static bool getCompatibleWithResponsiveScrolling() { + return _objc_msgSend_17( + _class_NSView, _sel_isCompatibleWithResponsiveScrolling); + } + + /// prepareContentInRect: + void prepareContentInRect_(CGRect rect) { + _objc_msgSend_60(this.pointer, _sel_prepareContentInRect_, rect); + } + + /// preparedContentRect + void getPreparedContentRect(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_21Stret(stret, this.pointer, _sel_preparedContentRect) + : stret.ref = _objc_msgSend_21(this.pointer, _sel_preparedContentRect); + } + + /// setPreparedContentRect: + set preparedContentRect(CGRect value) { + return _objc_msgSend_50(this.pointer, _sel_setPreparedContentRect_, value); + } + + /// allowsVibrancy + bool get allowsVibrancy { + return _objc_msgSend_17(this.pointer, _sel_allowsVibrancy); + } + + /// viewDidChangeEffectiveAppearance + void viewDidChangeEffectiveAppearance() { + _objc_msgSend_5(this.pointer, _sel_viewDidChangeEffectiveAppearance); + } + + /// init + NSView init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSView new1() { + final _ret = _objc_msgSend_34(_class_NSView, _sel_new); + return NSView.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSView allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSView, _sel_allocWithZone_, zone); + return NSView.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSView alloc() { + final _ret = _objc_msgSend_34(_class_NSView, _sel_alloc); + return NSView.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSView = objc.getClass("NSView"); +late final _sel_initWithFrame_ = objc.registerName("initWithFrame:"); +final _objc_msgSend_30 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +final _objc_msgSend_31 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_window = objc.registerName("window"); +final _objc_msgSend_32 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_superview = objc.registerName("superview"); +final _objc_msgSend_33 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_subviews = objc.registerName("subviews"); +final _objc_msgSend_34 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setSubviews_ = objc.registerName("setSubviews:"); +final _objc_msgSend_35 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isDescendantOf_ = objc.registerName("isDescendantOf:"); +final _objc_msgSend_36 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_ancestorSharedWithView_ = + objc.registerName("ancestorSharedWithView:"); +final _objc_msgSend_37 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_opaqueAncestor = objc.registerName("opaqueAncestor"); +late final _sel_isHidden = objc.registerName("isHidden"); +late final _sel_setHidden_ = objc.registerName("setHidden:"); +late final _sel_isHiddenOrHasHiddenAncestor = + objc.registerName("isHiddenOrHasHiddenAncestor"); +late final _sel_getRectsBeingDrawn_count_ = + objc.registerName("getRectsBeingDrawn:count:"); +final _objc_msgSend_38 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer)>(); +late final _sel_needsToDrawRect_ = objc.registerName("needsToDrawRect:"); +final _objc_msgSend_39 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_wantsDefaultClipping = + objc.registerName("wantsDefaultClipping"); +late final _sel_viewDidHide = objc.registerName("viewDidHide"); +late final _sel_viewDidUnhide = objc.registerName("viewDidUnhide"); +late final _sel_addSubview_ = objc.registerName("addSubview:"); +final _objc_msgSend_40 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +enum NSWindowOrderingMode { + NSWindowAbove(1), + NSWindowBelow(-1), + NSWindowOut(0); + + final int value; + const NSWindowOrderingMode(this.value); + + static NSWindowOrderingMode fromValue(int value) => switch (value) { + 1 => NSWindowAbove, + -1 => NSWindowBelow, + 0 => NSWindowOut, + _ => + throw ArgumentError("Unknown value for NSWindowOrderingMode: $value"), + }; +} + +late final _sel_addSubview_positioned_relativeTo_ = + objc.registerName("addSubview:positioned:relativeTo:"); +final _objc_msgSend_41 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Long, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_sortSubviewsUsingFunction_context_ = + objc.registerName("sortSubviewsUsingFunction:context:"); +final _objc_msgSend_42 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>, + ffi.Pointer)>(); +late final _sel_viewWillMoveToWindow_ = + objc.registerName("viewWillMoveToWindow:"); +final _objc_msgSend_43 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_viewDidMoveToWindow = objc.registerName("viewDidMoveToWindow"); +late final _sel_viewWillMoveToSuperview_ = + objc.registerName("viewWillMoveToSuperview:"); +final _objc_msgSend_44 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_viewDidMoveToSuperview = + objc.registerName("viewDidMoveToSuperview"); +late final _sel_didAddSubview_ = objc.registerName("didAddSubview:"); +late final _sel_willRemoveSubview_ = objc.registerName("willRemoveSubview:"); +late final _sel_removeFromSuperview = objc.registerName("removeFromSuperview"); +late final _sel_replaceSubview_with_ = + objc.registerName("replaceSubview:with:"); +final _objc_msgSend_45 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removeFromSuperviewWithoutNeedingDisplay = + objc.registerName("removeFromSuperviewWithoutNeedingDisplay"); +late final _sel_viewDidChangeBackingProperties = + objc.registerName("viewDidChangeBackingProperties"); +late final _sel_postsFrameChangedNotifications = + objc.registerName("postsFrameChangedNotifications"); +late final _sel_setPostsFrameChangedNotifications_ = + objc.registerName("setPostsFrameChangedNotifications:"); +late final _sel_resizeSubviewsWithOldSize_ = + objc.registerName("resizeSubviewsWithOldSize:"); +final _objc_msgSend_46 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGSize)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGSize)>(); +late final _sel_resizeWithOldSuperviewSize_ = + objc.registerName("resizeWithOldSuperviewSize:"); +late final _sel_autoresizesSubviews = objc.registerName("autoresizesSubviews"); +late final _sel_setAutoresizesSubviews_ = + objc.registerName("setAutoresizesSubviews:"); + +enum NSAutoresizingMaskOptions { + NSViewNotSizable(0), + NSViewMinXMargin(1), + NSViewWidthSizable(2), + NSViewMaxXMargin(4), + NSViewMinYMargin(8), + NSViewHeightSizable(16), + NSViewMaxYMargin(32); + + final int value; + const NSAutoresizingMaskOptions(this.value); + + static NSAutoresizingMaskOptions fromValue(int value) => switch (value) { + 0 => NSViewNotSizable, + 1 => NSViewMinXMargin, + 2 => NSViewWidthSizable, + 4 => NSViewMaxXMargin, + 8 => NSViewMinYMargin, + 16 => NSViewHeightSizable, + 32 => NSViewMaxYMargin, + _ => throw ArgumentError( + "Unknown value for NSAutoresizingMaskOptions: $value"), + }; +} + +late final _sel_autoresizingMask = objc.registerName("autoresizingMask"); +final _objc_msgSend_47 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAutoresizingMask_ = + objc.registerName("setAutoresizingMask:"); +final _objc_msgSend_48 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_setFrameOrigin_ = objc.registerName("setFrameOrigin:"); +final _objc_msgSend_49 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGPoint)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGPoint)>(); +late final _sel_setFrameSize_ = objc.registerName("setFrameSize:"); +late final _sel_frame = objc.registerName("frame"); +late final _sel_setFrame_ = objc.registerName("setFrame:"); +final _objc_msgSend_50 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_frameRotation = objc.registerName("frameRotation"); +final _objc_msgSend_51 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Double Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_51Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Double Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setFrameRotation_ = objc.registerName("setFrameRotation:"); +final _objc_msgSend_52 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_frameCenterRotation = objc.registerName("frameCenterRotation"); +late final _sel_setFrameCenterRotation_ = + objc.registerName("setFrameCenterRotation:"); +late final _sel_setBoundsOrigin_ = objc.registerName("setBoundsOrigin:"); +late final _sel_setBoundsSize_ = objc.registerName("setBoundsSize:"); +late final _sel_boundsRotation = objc.registerName("boundsRotation"); +late final _sel_setBoundsRotation_ = objc.registerName("setBoundsRotation:"); +late final _sel_translateOriginToPoint_ = + objc.registerName("translateOriginToPoint:"); +late final _sel_scaleUnitSquareToSize_ = + objc.registerName("scaleUnitSquareToSize:"); +late final _sel_rotateByAngle_ = objc.registerName("rotateByAngle:"); +final _objc_msgSend_53 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Double)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, double)>(); +late final _sel_bounds = objc.registerName("bounds"); +late final _sel_setBounds_ = objc.registerName("setBounds:"); +late final _sel_isFlipped = objc.registerName("isFlipped"); +late final _sel_isRotatedFromBase = objc.registerName("isRotatedFromBase"); +late final _sel_isRotatedOrScaledFromBase = + objc.registerName("isRotatedOrScaledFromBase"); +late final _sel_isOpaque = objc.registerName("isOpaque"); +late final _sel_convertPoint_fromView_ = + objc.registerName("convertPoint:fromView:"); +final _objc_msgSend_54 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>>() + .asFunction< + CGPoint Function( + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>(); +final _objc_msgSend_54Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>(); +late final _sel_convertPoint_toView_ = + objc.registerName("convertPoint:toView:"); +late final _sel_convertSize_fromView_ = + objc.registerName("convertSize:fromView:"); +final _objc_msgSend_55 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGSize Function( + ffi.Pointer, + ffi.Pointer, + CGSize, + ffi.Pointer)>>() + .asFunction< + CGSize Function( + ffi.Pointer, + ffi.Pointer, + CGSize, + ffi.Pointer)>(); +final _objc_msgSend_55Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGSize, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGSize, + ffi.Pointer)>(); +late final _sel_convertSize_toView_ = objc.registerName("convertSize:toView:"); +late final _sel_convertRect_fromView_ = + objc.registerName("convertRect:fromView:"); +final _objc_msgSend_56 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +final _objc_msgSend_56Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +late final _sel_convertRect_toView_ = objc.registerName("convertRect:toView:"); + +enum NSAlignmentOptions { + NSAlignMinXInward(1), + NSAlignMinYInward(2), + NSAlignMaxXInward(4), + NSAlignMaxYInward(8), + NSAlignWidthInward(16), + NSAlignHeightInward(32), + NSAlignMinXOutward(256), + NSAlignMinYOutward(512), + NSAlignMaxXOutward(1024), + NSAlignMaxYOutward(2048), + NSAlignWidthOutward(4096), + NSAlignHeightOutward(8192), + NSAlignMinXNearest(65536), + NSAlignMinYNearest(131072), + NSAlignMaxXNearest(262144), + NSAlignMaxYNearest(524288), + NSAlignWidthNearest(1048576), + NSAlignHeightNearest(2097152), + NSAlignRectFlipped(-9223372036854775808), + NSAlignAllEdgesInward(15), + NSAlignAllEdgesOutward(3840), + NSAlignAllEdgesNearest(983040); + + final int value; + const NSAlignmentOptions(this.value); + + static NSAlignmentOptions fromValue(int value) => switch (value) { + 1 => NSAlignMinXInward, + 2 => NSAlignMinYInward, + 4 => NSAlignMaxXInward, + 8 => NSAlignMaxYInward, + 16 => NSAlignWidthInward, + 32 => NSAlignHeightInward, + 256 => NSAlignMinXOutward, + 512 => NSAlignMinYOutward, + 1024 => NSAlignMaxXOutward, + 2048 => NSAlignMaxYOutward, + 4096 => NSAlignWidthOutward, + 8192 => NSAlignHeightOutward, + 65536 => NSAlignMinXNearest, + 131072 => NSAlignMinYNearest, + 262144 => NSAlignMaxXNearest, + 524288 => NSAlignMaxYNearest, + 1048576 => NSAlignWidthNearest, + 2097152 => NSAlignHeightNearest, + -9223372036854775808 => NSAlignRectFlipped, + 15 => NSAlignAllEdgesInward, + 3840 => NSAlignAllEdgesOutward, + 983040 => NSAlignAllEdgesNearest, + _ => + throw ArgumentError("Unknown value for NSAlignmentOptions: $value"), + }; +} + +late final _sel_backingAlignedRect_options_ = + objc.registerName("backingAlignedRect:options:"); +final _objc_msgSend_57 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer, CGRect, ffi.LongLong)>>() + .asFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer, CGRect, int)>(); +final _objc_msgSend_57Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGRect, ffi.LongLong)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGRect, int)>(); +late final _sel_centerScanRect_ = objc.registerName("centerScanRect:"); +late final _sel_convertPointToBacking_ = + objc.registerName("convertPointToBacking:"); +final _objc_msgSend_58 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGPoint Function(ffi.Pointer, + ffi.Pointer, CGPoint)>>() + .asFunction< + CGPoint Function(ffi.Pointer, + ffi.Pointer, CGPoint)>(); +final _objc_msgSend_58Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGPoint)>(); +late final _sel_convertPointFromBacking_ = + objc.registerName("convertPointFromBacking:"); +late final _sel_convertSizeToBacking_ = + objc.registerName("convertSizeToBacking:"); +final _objc_msgSend_59 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGSize Function(ffi.Pointer, + ffi.Pointer, CGSize)>>() + .asFunction< + CGSize Function(ffi.Pointer, + ffi.Pointer, CGSize)>(); +final _objc_msgSend_59Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGSize)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGSize)>(); +late final _sel_convertSizeFromBacking_ = + objc.registerName("convertSizeFromBacking:"); +late final _sel_convertRectToBacking_ = + objc.registerName("convertRectToBacking:"); +late final _sel_convertRectFromBacking_ = + objc.registerName("convertRectFromBacking:"); +late final _sel_convertPointToLayer_ = + objc.registerName("convertPointToLayer:"); +late final _sel_convertPointFromLayer_ = + objc.registerName("convertPointFromLayer:"); +late final _sel_convertSizeToLayer_ = objc.registerName("convertSizeToLayer:"); +late final _sel_convertSizeFromLayer_ = + objc.registerName("convertSizeFromLayer:"); +late final _sel_convertRectToLayer_ = objc.registerName("convertRectToLayer:"); +late final _sel_convertRectFromLayer_ = + objc.registerName("convertRectFromLayer:"); +late final _sel_canDrawConcurrently = objc.registerName("canDrawConcurrently"); +late final _sel_setCanDrawConcurrently_ = + objc.registerName("setCanDrawConcurrently:"); +late final _sel_canDraw = objc.registerName("canDraw"); +late final _sel_setNeedsDisplayInRect_ = + objc.registerName("setNeedsDisplayInRect:"); +final _objc_msgSend_60 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_needsDisplay = objc.registerName("needsDisplay"); +late final _sel_setNeedsDisplay_ = objc.registerName("setNeedsDisplay:"); +late final _sel_lockFocus = objc.registerName("lockFocus"); +late final _sel_unlockFocus = objc.registerName("unlockFocus"); +late final _sel_lockFocusIfCanDraw = objc.registerName("lockFocusIfCanDraw"); + +/// NSGraphicsContext +class NSGraphicsContext extends objc.ObjCObjectBase { + NSGraphicsContext._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSGraphicsContext] that points to the same underlying object as [other]. + NSGraphicsContext.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSGraphicsContext] that wraps the given raw object pointer. + NSGraphicsContext.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSGraphicsContext]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSGraphicsContext); + } +} + +late final _class_NSGraphicsContext = objc.getClass("NSGraphicsContext"); +late final _sel_lockFocusIfCanDrawInContext_ = + objc.registerName("lockFocusIfCanDrawInContext:"); +final _objc_msgSend_61 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_focusView = objc.registerName("focusView"); +late final _sel_visibleRect = objc.registerName("visibleRect"); +late final _sel_display = objc.registerName("display"); +late final _sel_displayIfNeeded = objc.registerName("displayIfNeeded"); +late final _sel_displayIfNeededIgnoringOpacity = + objc.registerName("displayIfNeededIgnoringOpacity"); +late final _sel_displayRect_ = objc.registerName("displayRect:"); +late final _sel_displayIfNeededInRect_ = + objc.registerName("displayIfNeededInRect:"); +late final _sel_displayRectIgnoringOpacity_ = + objc.registerName("displayRectIgnoringOpacity:"); +late final _sel_displayIfNeededInRectIgnoringOpacity_ = + objc.registerName("displayIfNeededInRectIgnoringOpacity:"); +late final _sel_drawRect_ = objc.registerName("drawRect:"); +late final _sel_displayRectIgnoringOpacity_inContext_ = + objc.registerName("displayRectIgnoringOpacity:inContext:"); +final _objc_msgSend_62 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); + +/// NSBitmapImageRep +class NSBitmapImageRep extends objc.ObjCObjectBase { + NSBitmapImageRep._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSBitmapImageRep] that points to the same underlying object as [other]. + NSBitmapImageRep.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSBitmapImageRep] that wraps the given raw object pointer. + NSBitmapImageRep.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSBitmapImageRep]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSBitmapImageRep); + } +} + +late final _class_NSBitmapImageRep = objc.getClass("NSBitmapImageRep"); +late final _sel_bitmapImageRepForCachingDisplayInRect_ = + objc.registerName("bitmapImageRepForCachingDisplayInRect:"); +final _objc_msgSend_63 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_cacheDisplayInRect_toBitmapImageRep_ = + objc.registerName("cacheDisplayInRect:toBitmapImageRep:"); +final _objc_msgSend_64 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +late final _sel_viewWillDraw = objc.registerName("viewWillDraw"); +late final _sel_scrollPoint_ = objc.registerName("scrollPoint:"); +late final _sel_scrollRectToVisible_ = + objc.registerName("scrollRectToVisible:"); + +/// NSEvent +class NSEvent extends objc.NSObject { + NSEvent._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSEvent] that points to the same underlying object as [other]. + NSEvent.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSEvent] that wraps the given raw object pointer. + NSEvent.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSEvent]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSEvent); + } + + /// type + NSEventType get type { + final _ret = _objc_msgSend_65(this.pointer, _sel_type); + return NSEventType.fromValue(_ret); + } + + /// modifierFlags + static NSEventModifierFlags getModifierFlags() { + final _ret = _objc_msgSend_66(_class_NSEvent, _sel_modifierFlags); + return NSEventModifierFlags.fromValue(_ret); + } + + /// timestamp + double get timestamp { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_timestamp) + : _objc_msgSend_51(this.pointer, _sel_timestamp); + } + + /// window + NSWindow? get window { + final _ret = _objc_msgSend_32(this.pointer, _sel_window); + return _ret.address == 0 + ? null + : NSWindow.castFromPointer(_ret, retain: true, release: true); + } + + /// windowNumber + int get windowNumber { + return _objc_msgSend_67(this.pointer, _sel_windowNumber); + } + + /// context + NSGraphicsContext? get context { + final _ret = _objc_msgSend_68(this.pointer, _sel_context); + return _ret.address == 0 + ? null + : NSGraphicsContext.castFromPointer(_ret, retain: true, release: true); + } + + /// clickCount + int get clickCount { + return _objc_msgSend_67(this.pointer, _sel_clickCount); + } + + /// buttonNumber + int get buttonNumber { + return _objc_msgSend_67(this.pointer, _sel_buttonNumber); + } + + /// eventNumber + int get eventNumber { + return _objc_msgSend_67(this.pointer, _sel_eventNumber); + } + + /// pressure + double get pressure { + return objc.useMsgSendVariants + ? _objc_msgSend_69Fpret(this.pointer, _sel_pressure) + : _objc_msgSend_69(this.pointer, _sel_pressure); + } + + /// locationInWindow + void getLocationInWindow(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_70Stret(stret, this.pointer, _sel_locationInWindow) + : stret.ref = _objc_msgSend_70(this.pointer, _sel_locationInWindow); + } + + /// deltaX + double get deltaX { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_deltaX) + : _objc_msgSend_51(this.pointer, _sel_deltaX); + } + + /// deltaY + double get deltaY { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_deltaY) + : _objc_msgSend_51(this.pointer, _sel_deltaY); + } + + /// deltaZ + double get deltaZ { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_deltaZ) + : _objc_msgSend_51(this.pointer, _sel_deltaZ); + } + + /// hasPreciseScrollingDeltas + bool get hasPreciseScrollingDeltas { + return _objc_msgSend_17(this.pointer, _sel_hasPreciseScrollingDeltas); + } + + /// scrollingDeltaX + double get scrollingDeltaX { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_scrollingDeltaX) + : _objc_msgSend_51(this.pointer, _sel_scrollingDeltaX); + } + + /// scrollingDeltaY + double get scrollingDeltaY { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_scrollingDeltaY) + : _objc_msgSend_51(this.pointer, _sel_scrollingDeltaY); + } + + /// momentumPhase + NSEventPhase get momentumPhase { + final _ret = _objc_msgSend_71(this.pointer, _sel_momentumPhase); + return NSEventPhase.fromValue(_ret); + } + + /// isDirectionInvertedFromDevice + bool get directionInvertedFromDevice { + return _objc_msgSend_17(this.pointer, _sel_isDirectionInvertedFromDevice); + } + + /// characters + objc.NSString? get characters { + final _ret = _objc_msgSend_72(this.pointer, _sel_characters); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// charactersIgnoringModifiers + objc.NSString? get charactersIgnoringModifiers { + final _ret = + _objc_msgSend_72(this.pointer, _sel_charactersIgnoringModifiers); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// charactersByApplyingModifiers: + objc.NSString? charactersByApplyingModifiers_( + NSEventModifierFlags modifiers) { + final _ret = _objc_msgSend_73( + this.pointer, _sel_charactersByApplyingModifiers_, modifiers.value); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// isARepeat + bool get ARepeat { + return _objc_msgSend_17(this.pointer, _sel_isARepeat); + } + + /// keyCode + int get keyCode { + return _objc_msgSend_74(this.pointer, _sel_keyCode); + } + + /// trackingNumber + int get trackingNumber { + return _objc_msgSend_67(this.pointer, _sel_trackingNumber); + } + + /// userData + ffi.Pointer get userData { + return _objc_msgSend_75(this.pointer, _sel_userData); + } + + /// trackingArea + NSTrackingArea? get trackingArea { + final _ret = _objc_msgSend_76(this.pointer, _sel_trackingArea); + return _ret.address == 0 + ? null + : NSTrackingArea.castFromPointer(_ret, retain: true, release: true); + } + + /// subtype + NSEventSubtype get subtype { + final _ret = _objc_msgSend_77(this.pointer, _sel_subtype); + return NSEventSubtype.fromValue(_ret); + } + + /// data1 + int get data1 { + return _objc_msgSend_67(this.pointer, _sel_data1); + } + + /// data2 + int get data2 { + return _objc_msgSend_67(this.pointer, _sel_data2); + } + + /// eventRef + ffi.Pointer get eventRef { + return _objc_msgSend_75(this.pointer, _sel_eventRef); + } + + /// eventWithEventRef: + static NSEvent? eventWithEventRef_(ffi.Pointer eventRef) { + final _ret = + _objc_msgSend_78(_class_NSEvent, _sel_eventWithEventRef_, eventRef); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// CGEvent + ffi.Pointer<__CGEvent> get CGEvent { + return _objc_msgSend_79(this.pointer, _sel_CGEvent); + } + + /// eventWithCGEvent: + static NSEvent? eventWithCGEvent_(ffi.Pointer<__CGEvent> cgEvent) { + final _ret = + _objc_msgSend_80(_class_NSEvent, _sel_eventWithCGEvent_, cgEvent); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// isMouseCoalescingEnabled + static bool getMouseCoalescingEnabled() { + return _objc_msgSend_17(_class_NSEvent, _sel_isMouseCoalescingEnabled); + } + + /// setMouseCoalescingEnabled: + static void setMouseCoalescingEnabled(bool value) { + return _objc_msgSend_18( + _class_NSEvent, _sel_setMouseCoalescingEnabled_, value); + } + + /// magnification + double get magnification { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_magnification) + : _objc_msgSend_51(this.pointer, _sel_magnification); + } + + /// deviceID + int get deviceID { + return _objc_msgSend_81(this.pointer, _sel_deviceID); + } + + /// rotation + double get rotation { + return objc.useMsgSendVariants + ? _objc_msgSend_69Fpret(this.pointer, _sel_rotation) + : _objc_msgSend_69(this.pointer, _sel_rotation); + } + + /// absoluteX + int get absoluteX { + return _objc_msgSend_67(this.pointer, _sel_absoluteX); + } + + /// absoluteY + int get absoluteY { + return _objc_msgSend_67(this.pointer, _sel_absoluteY); + } + + /// absoluteZ + int get absoluteZ { + return _objc_msgSend_67(this.pointer, _sel_absoluteZ); + } + + /// buttonMask + NSEventButtonMask get buttonMask { + final _ret = _objc_msgSend_82(this.pointer, _sel_buttonMask); + return NSEventButtonMask.fromValue(_ret); + } + + /// tilt + void getTilt(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_70Stret(stret, this.pointer, _sel_tilt) + : stret.ref = _objc_msgSend_70(this.pointer, _sel_tilt); + } + + /// tangentialPressure + double get tangentialPressure { + return objc.useMsgSendVariants + ? _objc_msgSend_69Fpret(this.pointer, _sel_tangentialPressure) + : _objc_msgSend_69(this.pointer, _sel_tangentialPressure); + } + + /// vendorDefined + objc.ObjCObjectBase get vendorDefined { + final _ret = _objc_msgSend_34(this.pointer, _sel_vendorDefined); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// vendorID + int get vendorID { + return _objc_msgSend_81(this.pointer, _sel_vendorID); + } + + /// tabletID + int get tabletID { + return _objc_msgSend_81(this.pointer, _sel_tabletID); + } + + /// pointingDeviceID + int get pointingDeviceID { + return _objc_msgSend_81(this.pointer, _sel_pointingDeviceID); + } + + /// systemTabletID + int get systemTabletID { + return _objc_msgSend_81(this.pointer, _sel_systemTabletID); + } + + /// vendorPointingDeviceType + int get vendorPointingDeviceType { + return _objc_msgSend_81(this.pointer, _sel_vendorPointingDeviceType); + } + + /// pointingDeviceSerialNumber + int get pointingDeviceSerialNumber { + return _objc_msgSend_81(this.pointer, _sel_pointingDeviceSerialNumber); + } + + /// uniqueID + int get uniqueID { + return _objc_msgSend_83(this.pointer, _sel_uniqueID); + } + + /// capabilityMask + int get capabilityMask { + return _objc_msgSend_81(this.pointer, _sel_capabilityMask); + } + + /// pointingDeviceType + NSPointingDeviceType get pointingDeviceType { + final _ret = _objc_msgSend_84(this.pointer, _sel_pointingDeviceType); + return NSPointingDeviceType.fromValue(_ret); + } + + /// isEnteringProximity + bool get enteringProximity { + return _objc_msgSend_17(this.pointer, _sel_isEnteringProximity); + } + + /// touchesMatchingPhase:inView: + objc.ObjCObjectBase touchesMatchingPhase_inView_( + NSTouchPhase phase, NSView? view) { + final _ret = _objc_msgSend_85( + this.pointer, + _sel_touchesMatchingPhase_inView_, + phase.value, + view?.pointer ?? ffi.nullptr); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// allTouches + objc.ObjCObjectBase allTouches() { + final _ret = _objc_msgSend_34(this.pointer, _sel_allTouches); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// touchesForView: + objc.ObjCObjectBase touchesForView_(NSView view) { + final _ret = + _objc_msgSend_86(this.pointer, _sel_touchesForView_, view.pointer); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// coalescedTouchesForTouch: + objc.ObjCObjectBase coalescedTouchesForTouch_(NSTouch touch) { + final _ret = _objc_msgSend_90( + this.pointer, _sel_coalescedTouchesForTouch_, touch.pointer); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// phase + NSEventPhase get phase { + final _ret = _objc_msgSend_71(this.pointer, _sel_phase); + return NSEventPhase.fromValue(_ret); + } + + /// stage + int get stage { + return _objc_msgSend_67(this.pointer, _sel_stage); + } + + /// stageTransition + double get stageTransition { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_stageTransition) + : _objc_msgSend_51(this.pointer, _sel_stageTransition); + } + + /// associatedEventsMask + NSEventMask get associatedEventsMask { + final _ret = _objc_msgSend_91(this.pointer, _sel_associatedEventsMask); + return NSEventMask.fromValue(_ret); + } + + /// pressureBehavior + NSPressureBehavior get pressureBehavior { + final _ret = _objc_msgSend_92(this.pointer, _sel_pressureBehavior); + return NSPressureBehavior.fromValue(_ret); + } + + /// isSwipeTrackingFromScrollEventsEnabled + static bool getSwipeTrackingFromScrollEventsEnabled() { + return _objc_msgSend_17( + _class_NSEvent, _sel_isSwipeTrackingFromScrollEventsEnabled); + } + + /// trackSwipeEventWithOptions:dampenAmountThresholdMin:max:usingHandler: + void trackSwipeEventWithOptions_dampenAmountThresholdMin_max_usingHandler_( + NSEventSwipeTrackingOptions options, + double minDampenThreshold, + double maxDampenThreshold, + ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool trackingHandler) { + _objc_msgSend_93( + this.pointer, + _sel_trackSwipeEventWithOptions_dampenAmountThresholdMin_max_usingHandler_, + options.value, + minDampenThreshold, + maxDampenThreshold, + trackingHandler.pointer); + } + + /// startPeriodicEventsAfterDelay:withPeriod: + static void startPeriodicEventsAfterDelay_withPeriod_( + double delay, double period) { + _objc_msgSend_94(_class_NSEvent, + _sel_startPeriodicEventsAfterDelay_withPeriod_, delay, period); + } + + /// stopPeriodicEvents + static void stopPeriodicEvents() { + _objc_msgSend_5(_class_NSEvent, _sel_stopPeriodicEvents); + } + + /// mouseEventWithType:location:modifierFlags:timestamp:windowNumber:context:eventNumber:clickCount:pressure: + static NSEvent? + mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure_( + NSEventType type, + CGPoint location, + NSEventModifierFlags flags, + double time, + int wNum, + NSGraphicsContext? unusedPassNil, + int eNum, + int cNum, + double pressure) { + final _ret = _objc_msgSend_95( + _class_NSEvent, + _sel_mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure_, + type.value, + location, + flags.value, + time, + wNum, + unusedPassNil?.pointer ?? ffi.nullptr, + eNum, + cNum, + pressure); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// keyEventWithType:location:modifierFlags:timestamp:windowNumber:context:characters:charactersIgnoringModifiers:isARepeat:keyCode: + static NSEvent? + keyEventWithType_location_modifierFlags_timestamp_windowNumber_context_characters_charactersIgnoringModifiers_isARepeat_keyCode_( + NSEventType type, + CGPoint location, + NSEventModifierFlags flags, + double time, + int wNum, + NSGraphicsContext? unusedPassNil, + objc.NSString keys, + objc.NSString ukeys, + bool flag, + int code) { + final _ret = _objc_msgSend_96( + _class_NSEvent, + _sel_keyEventWithType_location_modifierFlags_timestamp_windowNumber_context_characters_charactersIgnoringModifiers_isARepeat_keyCode_, + type.value, + location, + flags.value, + time, + wNum, + unusedPassNil?.pointer ?? ffi.nullptr, + keys.pointer, + ukeys.pointer, + flag, + code); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// enterExitEventWithType:location:modifierFlags:timestamp:windowNumber:context:eventNumber:trackingNumber:userData: + static NSEvent? + enterExitEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_trackingNumber_userData_( + NSEventType type, + CGPoint location, + NSEventModifierFlags flags, + double time, + int wNum, + NSGraphicsContext? unusedPassNil, + int eNum, + int tNum, + ffi.Pointer data) { + final _ret = _objc_msgSend_97( + _class_NSEvent, + _sel_enterExitEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_trackingNumber_userData_, + type.value, + location, + flags.value, + time, + wNum, + unusedPassNil?.pointer ?? ffi.nullptr, + eNum, + tNum, + data); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// otherEventWithType:location:modifierFlags:timestamp:windowNumber:context:subtype:data1:data2: + static NSEvent? + otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2_( + NSEventType type, + CGPoint location, + NSEventModifierFlags flags, + double time, + int wNum, + NSGraphicsContext? unusedPassNil, + int subtype, + int d1, + int d2) { + final _ret = _objc_msgSend_98( + _class_NSEvent, + _sel_otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2_, + type.value, + location, + flags.value, + time, + wNum, + unusedPassNil?.pointer ?? ffi.nullptr, + subtype, + d1, + d2); + return _ret.address == 0 + ? null + : NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// mouseLocation + static void getMouseLocation(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_70Stret(stret, _class_NSEvent, _sel_mouseLocation) + : stret.ref = _objc_msgSend_70(_class_NSEvent, _sel_mouseLocation); + } + + /// pressedMouseButtons + static int getPressedMouseButtons() { + return _objc_msgSend_81(_class_NSEvent, _sel_pressedMouseButtons); + } + + /// doubleClickInterval + static double getDoubleClickInterval() { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(_class_NSEvent, _sel_doubleClickInterval) + : _objc_msgSend_51(_class_NSEvent, _sel_doubleClickInterval); + } + + /// keyRepeatDelay + static double getKeyRepeatDelay() { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(_class_NSEvent, _sel_keyRepeatDelay) + : _objc_msgSend_51(_class_NSEvent, _sel_keyRepeatDelay); + } + + /// keyRepeatInterval + static double getKeyRepeatInterval() { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(_class_NSEvent, _sel_keyRepeatInterval) + : _objc_msgSend_51(_class_NSEvent, _sel_keyRepeatInterval); + } + + /// addGlobalMonitorForEventsMatchingMask:handler: + static objc.ObjCObjectBase? addGlobalMonitorForEventsMatchingMask_handler_( + NSEventMask mask, ObjCBlock_ffiVoid_NSEvent block) { + final _ret = _objc_msgSend_99( + _class_NSEvent, + _sel_addGlobalMonitorForEventsMatchingMask_handler_, + mask.value, + block.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// addLocalMonitorForEventsMatchingMask:handler: + static objc.ObjCObjectBase? addLocalMonitorForEventsMatchingMask_handler_( + NSEventMask mask, ObjCBlock_NSEvent_NSEvent block) { + final _ret = _objc_msgSend_100( + _class_NSEvent, + _sel_addLocalMonitorForEventsMatchingMask_handler_, + mask.value, + block.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// removeMonitor: + static void removeMonitor_(objc.ObjCObjectBase eventMonitor) { + _objc_msgSend_101( + _class_NSEvent, _sel_removeMonitor_, eventMonitor.pointer); + } + + /// init + NSEvent init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSEvent.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSEvent new1() { + final _ret = _objc_msgSend_34(_class_NSEvent, _sel_new); + return NSEvent.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSEvent allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSEvent, _sel_allocWithZone_, zone); + return NSEvent.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSEvent alloc() { + final _ret = _objc_msgSend_34(_class_NSEvent, _sel_alloc); + return NSEvent.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSEvent = objc.getClass("NSEvent"); + +enum NSEventType { + NSEventTypeLeftMouseDown(1), + NSEventTypeLeftMouseUp(2), + NSEventTypeRightMouseDown(3), + NSEventTypeRightMouseUp(4), + NSEventTypeMouseMoved(5), + NSEventTypeLeftMouseDragged(6), + NSEventTypeRightMouseDragged(7), + NSEventTypeMouseEntered(8), + NSEventTypeMouseExited(9), + NSEventTypeKeyDown(10), + NSEventTypeKeyUp(11), + NSEventTypeFlagsChanged(12), + NSEventTypeAppKitDefined(13), + NSEventTypeSystemDefined(14), + NSEventTypeApplicationDefined(15), + NSEventTypePeriodic(16), + NSEventTypeCursorUpdate(17), + NSEventTypeScrollWheel(22), + NSEventTypeTabletPoint(23), + NSEventTypeTabletProximity(24), + NSEventTypeOtherMouseDown(25), + NSEventTypeOtherMouseUp(26), + NSEventTypeOtherMouseDragged(27), + NSEventTypeGesture(29), + NSEventTypeMagnify(30), + NSEventTypeSwipe(31), + NSEventTypeRotate(18), + NSEventTypeBeginGesture(19), + NSEventTypeEndGesture(20), + NSEventTypeSmartMagnify(32), + NSEventTypeQuickLook(33), + NSEventTypePressure(34), + NSEventTypeDirectTouch(37), + NSEventTypeChangeMode(38); + + final int value; + const NSEventType(this.value); + + static NSEventType fromValue(int value) => switch (value) { + 1 => NSEventTypeLeftMouseDown, + 2 => NSEventTypeLeftMouseUp, + 3 => NSEventTypeRightMouseDown, + 4 => NSEventTypeRightMouseUp, + 5 => NSEventTypeMouseMoved, + 6 => NSEventTypeLeftMouseDragged, + 7 => NSEventTypeRightMouseDragged, + 8 => NSEventTypeMouseEntered, + 9 => NSEventTypeMouseExited, + 10 => NSEventTypeKeyDown, + 11 => NSEventTypeKeyUp, + 12 => NSEventTypeFlagsChanged, + 13 => NSEventTypeAppKitDefined, + 14 => NSEventTypeSystemDefined, + 15 => NSEventTypeApplicationDefined, + 16 => NSEventTypePeriodic, + 17 => NSEventTypeCursorUpdate, + 22 => NSEventTypeScrollWheel, + 23 => NSEventTypeTabletPoint, + 24 => NSEventTypeTabletProximity, + 25 => NSEventTypeOtherMouseDown, + 26 => NSEventTypeOtherMouseUp, + 27 => NSEventTypeOtherMouseDragged, + 29 => NSEventTypeGesture, + 30 => NSEventTypeMagnify, + 31 => NSEventTypeSwipe, + 18 => NSEventTypeRotate, + 19 => NSEventTypeBeginGesture, + 20 => NSEventTypeEndGesture, + 32 => NSEventTypeSmartMagnify, + 33 => NSEventTypeQuickLook, + 34 => NSEventTypePressure, + 37 => NSEventTypeDirectTouch, + 38 => NSEventTypeChangeMode, + _ => throw ArgumentError("Unknown value for NSEventType: $value"), + }; +} + +late final _sel_type = objc.registerName("type"); +final _objc_msgSend_65 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum NSEventModifierFlags { + NSEventModifierFlagCapsLock(65536), + NSEventModifierFlagShift(131072), + NSEventModifierFlagControl(262144), + NSEventModifierFlagOption(524288), + NSEventModifierFlagCommand(1048576), + NSEventModifierFlagNumericPad(2097152), + NSEventModifierFlagHelp(4194304), + NSEventModifierFlagFunction(8388608), + NSEventModifierFlagDeviceIndependentFlagsMask(4294901760); + + final int value; + const NSEventModifierFlags(this.value); + + static NSEventModifierFlags fromValue(int value) => switch (value) { + 65536 => NSEventModifierFlagCapsLock, + 131072 => NSEventModifierFlagShift, + 262144 => NSEventModifierFlagControl, + 524288 => NSEventModifierFlagOption, + 1048576 => NSEventModifierFlagCommand, + 2097152 => NSEventModifierFlagNumericPad, + 4194304 => NSEventModifierFlagHelp, + 8388608 => NSEventModifierFlagFunction, + 4294901760 => NSEventModifierFlagDeviceIndependentFlagsMask, + _ => + throw ArgumentError("Unknown value for NSEventModifierFlags: $value"), + }; +} + +late final _sel_modifierFlags = objc.registerName("modifierFlags"); +final _objc_msgSend_66 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_timestamp = objc.registerName("timestamp"); +late final _sel_windowNumber = objc.registerName("windowNumber"); +final _objc_msgSend_67 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_context = objc.registerName("context"); +final _objc_msgSend_68 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_clickCount = objc.registerName("clickCount"); +late final _sel_buttonNumber = objc.registerName("buttonNumber"); +late final _sel_eventNumber = objc.registerName("eventNumber"); +late final _sel_pressure = objc.registerName("pressure"); +final _objc_msgSend_69 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Float Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_69Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Float Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + double Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_locationInWindow = objc.registerName("locationInWindow"); +final _objc_msgSend_70 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGPoint Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGPoint Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_70Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); +late final _sel_deltaX = objc.registerName("deltaX"); +late final _sel_deltaY = objc.registerName("deltaY"); +late final _sel_deltaZ = objc.registerName("deltaZ"); +late final _sel_hasPreciseScrollingDeltas = + objc.registerName("hasPreciseScrollingDeltas"); +late final _sel_scrollingDeltaX = objc.registerName("scrollingDeltaX"); +late final _sel_scrollingDeltaY = objc.registerName("scrollingDeltaY"); + +enum NSEventPhase { + NSEventPhaseNone(0), + NSEventPhaseBegan(1), + NSEventPhaseStationary(2), + NSEventPhaseChanged(4), + NSEventPhaseEnded(8), + NSEventPhaseCancelled(16), + NSEventPhaseMayBegin(32); + + final int value; + const NSEventPhase(this.value); + + static NSEventPhase fromValue(int value) => switch (value) { + 0 => NSEventPhaseNone, + 1 => NSEventPhaseBegan, + 2 => NSEventPhaseStationary, + 4 => NSEventPhaseChanged, + 8 => NSEventPhaseEnded, + 16 => NSEventPhaseCancelled, + 32 => NSEventPhaseMayBegin, + _ => throw ArgumentError("Unknown value for NSEventPhase: $value"), + }; +} + +late final _sel_momentumPhase = objc.registerName("momentumPhase"); +final _objc_msgSend_71 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isDirectionInvertedFromDevice = + objc.registerName("isDirectionInvertedFromDevice"); +late final _sel_characters = objc.registerName("characters"); +final _objc_msgSend_72 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_charactersIgnoringModifiers = + objc.registerName("charactersIgnoringModifiers"); +late final _sel_charactersByApplyingModifiers_ = + objc.registerName("charactersByApplyingModifiers:"); +final _objc_msgSend_73 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_isARepeat = objc.registerName("isARepeat"); +late final _sel_keyCode = objc.registerName("keyCode"); +final _objc_msgSend_74 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedShort Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_trackingNumber = objc.registerName("trackingNumber"); +late final _sel_userData = objc.registerName("userData"); +final _objc_msgSend_75 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSTrackingArea +class NSTrackingArea extends objc.ObjCObjectBase { + NSTrackingArea._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSTrackingArea] that points to the same underlying object as [other]. + NSTrackingArea.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSTrackingArea] that wraps the given raw object pointer. + NSTrackingArea.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSTrackingArea]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSTrackingArea); + } +} + +late final _class_NSTrackingArea = objc.getClass("NSTrackingArea"); +late final _sel_trackingArea = objc.registerName("trackingArea"); +final _objc_msgSend_76 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +enum NSEventSubtype { + NSEventSubtypeWindowExposed(0), + NSEventSubtypeApplicationActivated(1), + NSEventSubtypeApplicationDeactivated(2), + NSEventSubtypeWindowMoved(4), + NSEventSubtypeScreenChanged(8), + NSEventSubtypeTouch(3); + + static const NSEventSubtypePowerOff = NSEventSubtypeApplicationActivated; + static const NSEventSubtypeMouseEvent = NSEventSubtypeWindowExposed; + static const NSEventSubtypeTabletPoint = NSEventSubtypeApplicationActivated; + static const NSEventSubtypeTabletProximity = + NSEventSubtypeApplicationDeactivated; + + final int value; + const NSEventSubtype(this.value); + + static NSEventSubtype fromValue(int value) => switch (value) { + 0 => NSEventSubtypeWindowExposed, + 1 => NSEventSubtypeApplicationActivated, + 2 => NSEventSubtypeApplicationDeactivated, + 4 => NSEventSubtypeWindowMoved, + 8 => NSEventSubtypeScreenChanged, + 3 => NSEventSubtypeTouch, + _ => throw ArgumentError("Unknown value for NSEventSubtype: $value"), + }; + + @override + String toString() { + if (this == NSEventSubtypeWindowExposed) + return "NSEventSubtype.NSEventSubtypeWindowExposed, NSEventSubtype.NSEventSubtypeMouseEvent"; + if (this == NSEventSubtypeApplicationActivated) + return "NSEventSubtype.NSEventSubtypeApplicationActivated, NSEventSubtype.NSEventSubtypePowerOff, NSEventSubtype.NSEventSubtypeTabletPoint"; + if (this == NSEventSubtypeApplicationDeactivated) + return "NSEventSubtype.NSEventSubtypeApplicationDeactivated, NSEventSubtype.NSEventSubtypeTabletProximity"; + return super.toString(); + } +} + +late final _sel_subtype = objc.registerName("subtype"); +final _objc_msgSend_77 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedShort Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_data1 = objc.registerName("data1"); +late final _sel_data2 = objc.registerName("data2"); +late final _sel_eventRef = objc.registerName("eventRef"); +late final _sel_eventWithEventRef_ = objc.registerName("eventWithEventRef:"); +final _objc_msgSend_78 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +final class __CGEvent extends ffi.Opaque {} + +late final _sel_CGEvent = objc.registerName("CGEvent"); +final _objc_msgSend_79 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer<__CGEvent> Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer<__CGEvent> Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_eventWithCGEvent_ = objc.registerName("eventWithCGEvent:"); +final _objc_msgSend_80 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__CGEvent>)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<__CGEvent>)>(); +late final _sel_isMouseCoalescingEnabled = + objc.registerName("isMouseCoalescingEnabled"); +late final _sel_setMouseCoalescingEnabled_ = + objc.registerName("setMouseCoalescingEnabled:"); +late final _sel_magnification = objc.registerName("magnification"); +late final _sel_deviceID = objc.registerName("deviceID"); +final _objc_msgSend_81 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_rotation = objc.registerName("rotation"); +late final _sel_absoluteX = objc.registerName("absoluteX"); +late final _sel_absoluteY = objc.registerName("absoluteY"); +late final _sel_absoluteZ = objc.registerName("absoluteZ"); + +enum NSEventButtonMask { + NSEventButtonMaskPenTip(1), + NSEventButtonMaskPenLowerSide(2), + NSEventButtonMaskPenUpperSide(4); + + final int value; + const NSEventButtonMask(this.value); + + static NSEventButtonMask fromValue(int value) => switch (value) { + 1 => NSEventButtonMaskPenTip, + 2 => NSEventButtonMaskPenLowerSide, + 4 => NSEventButtonMaskPenUpperSide, + _ => throw ArgumentError("Unknown value for NSEventButtonMask: $value"), + }; +} + +late final _sel_buttonMask = objc.registerName("buttonMask"); +final _objc_msgSend_82 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_tilt = objc.registerName("tilt"); +late final _sel_tangentialPressure = objc.registerName("tangentialPressure"); +late final _sel_vendorDefined = objc.registerName("vendorDefined"); +late final _sel_vendorID = objc.registerName("vendorID"); +late final _sel_tabletID = objc.registerName("tabletID"); +late final _sel_pointingDeviceID = objc.registerName("pointingDeviceID"); +late final _sel_systemTabletID = objc.registerName("systemTabletID"); +late final _sel_vendorPointingDeviceType = + objc.registerName("vendorPointingDeviceType"); +late final _sel_pointingDeviceSerialNumber = + objc.registerName("pointingDeviceSerialNumber"); +late final _sel_uniqueID = objc.registerName("uniqueID"); +final _objc_msgSend_83 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLongLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_capabilityMask = objc.registerName("capabilityMask"); + +enum NSPointingDeviceType { + NSPointingDeviceTypeUnknown(0), + NSPointingDeviceTypePen(1), + NSPointingDeviceTypeCursor(2), + NSPointingDeviceTypeEraser(3); + + final int value; + const NSPointingDeviceType(this.value); + + static NSPointingDeviceType fromValue(int value) => switch (value) { + 0 => NSPointingDeviceTypeUnknown, + 1 => NSPointingDeviceTypePen, + 2 => NSPointingDeviceTypeCursor, + 3 => NSPointingDeviceTypeEraser, + _ => + throw ArgumentError("Unknown value for NSPointingDeviceType: $value"), + }; +} + +late final _sel_pointingDeviceType = objc.registerName("pointingDeviceType"); +final _objc_msgSend_84 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isEnteringProximity = objc.registerName("isEnteringProximity"); + +enum NSTouchPhase { + NSTouchPhaseBegan(1), + NSTouchPhaseMoved(2), + NSTouchPhaseStationary(4), + NSTouchPhaseEnded(8), + NSTouchPhaseCancelled(16), + NSTouchPhaseTouching(7), + NSTouchPhaseAny(-1); + + final int value; + const NSTouchPhase(this.value); + + static NSTouchPhase fromValue(int value) => switch (value) { + 1 => NSTouchPhaseBegan, + 2 => NSTouchPhaseMoved, + 4 => NSTouchPhaseStationary, + 8 => NSTouchPhaseEnded, + 16 => NSTouchPhaseCancelled, + 7 => NSTouchPhaseTouching, + -1 => NSTouchPhaseAny, + _ => throw ArgumentError("Unknown value for NSTouchPhase: $value"), + }; +} + +late final _sel_touchesMatchingPhase_inView_ = + objc.registerName("touchesMatchingPhase:inView:"); +final _objc_msgSend_85 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Long, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_allTouches = objc.registerName("allTouches"); +late final _sel_touchesForView_ = objc.registerName("touchesForView:"); +final _objc_msgSend_86 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// NSTouch +class NSTouch extends objc.NSObject { + NSTouch._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSTouch] that points to the same underlying object as [other]. + NSTouch.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSTouch] that wraps the given raw object pointer. + NSTouch.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSTouch]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSTouch); + } + + /// identity + objc.ObjCObjectBase get identity { + final _ret = _objc_msgSend_34(this.pointer, _sel_identity); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// phase + NSTouchPhase get phase { + final _ret = _objc_msgSend_87(this.pointer, _sel_phase); + return NSTouchPhase.fromValue(_ret); + } + + /// normalizedPosition + void getNormalizedPosition(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_70Stret(stret, this.pointer, _sel_normalizedPosition) + : stret.ref = _objc_msgSend_70(this.pointer, _sel_normalizedPosition); + } + + /// isResting + bool get resting { + return _objc_msgSend_17(this.pointer, _sel_isResting); + } + + /// device + objc.ObjCObjectBase? get device { + final _ret = _objc_msgSend_2(this.pointer, _sel_device); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// deviceSize + void getDeviceSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_deviceSize) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_deviceSize); + } + + /// init + NSTouch init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSTouch.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSTouch new1() { + final _ret = _objc_msgSend_34(_class_NSTouch, _sel_new); + return NSTouch.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSTouch allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSTouch, _sel_allocWithZone_, zone); + return NSTouch.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSTouch alloc() { + final _ret = _objc_msgSend_34(_class_NSTouch, _sel_alloc); + return NSTouch.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSTouch = objc.getClass("NSTouch"); +late final _sel_identity = objc.registerName("identity"); +late final _sel_phase = objc.registerName("phase"); +final _objc_msgSend_87 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_normalizedPosition = objc.registerName("normalizedPosition"); +late final _sel_isResting = objc.registerName("isResting"); +late final _sel_device = objc.registerName("device"); +late final _sel_deviceSize = objc.registerName("deviceSize"); +final _objc_msgSend_88 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGSize Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + CGSize Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_88Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>(); +late final _sel_init = objc.registerName("init"); +late final _sel_new = objc.registerName("new"); + +final class _NSZone extends ffi.Opaque {} + +late final _sel_allocWithZone_ = objc.registerName("allocWithZone:"); +final _objc_msgSend_89 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<_NSZone>)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<_NSZone>)>(); +late final _sel_alloc = objc.registerName("alloc"); +late final _sel_coalescedTouchesForTouch_ = + objc.registerName("coalescedTouchesForTouch:"); +final _objc_msgSend_90 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_stage = objc.registerName("stage"); +late final _sel_stageTransition = objc.registerName("stageTransition"); + +enum NSEventMask { + NSEventMaskLeftMouseDown(2), + NSEventMaskLeftMouseUp(4), + NSEventMaskRightMouseDown(8), + NSEventMaskRightMouseUp(16), + NSEventMaskMouseMoved(32), + NSEventMaskLeftMouseDragged(64), + NSEventMaskRightMouseDragged(128), + NSEventMaskMouseEntered(256), + NSEventMaskMouseExited(512), + NSEventMaskKeyDown(1024), + NSEventMaskKeyUp(2048), + NSEventMaskFlagsChanged(4096), + NSEventMaskAppKitDefined(8192), + NSEventMaskSystemDefined(16384), + NSEventMaskApplicationDefined(32768), + NSEventMaskPeriodic(65536), + NSEventMaskCursorUpdate(131072), + NSEventMaskScrollWheel(4194304), + NSEventMaskTabletPoint(8388608), + NSEventMaskTabletProximity(16777216), + NSEventMaskOtherMouseDown(33554432), + NSEventMaskOtherMouseUp(67108864), + NSEventMaskOtherMouseDragged(134217728), + NSEventMaskGesture(536870912), + NSEventMaskMagnify(1073741824), + NSEventMaskSwipe(2147483648), + NSEventMaskRotate(262144), + NSEventMaskBeginGesture(524288), + NSEventMaskEndGesture(1048576), + NSEventMaskSmartMagnify(4294967296), + NSEventMaskPressure(17179869184), + NSEventMaskDirectTouch(137438953472), + NSEventMaskChangeMode(274877906944), + NSEventMaskAny(-1); + + final int value; + const NSEventMask(this.value); + + static NSEventMask fromValue(int value) => switch (value) { + 2 => NSEventMaskLeftMouseDown, + 4 => NSEventMaskLeftMouseUp, + 8 => NSEventMaskRightMouseDown, + 16 => NSEventMaskRightMouseUp, + 32 => NSEventMaskMouseMoved, + 64 => NSEventMaskLeftMouseDragged, + 128 => NSEventMaskRightMouseDragged, + 256 => NSEventMaskMouseEntered, + 512 => NSEventMaskMouseExited, + 1024 => NSEventMaskKeyDown, + 2048 => NSEventMaskKeyUp, + 4096 => NSEventMaskFlagsChanged, + 8192 => NSEventMaskAppKitDefined, + 16384 => NSEventMaskSystemDefined, + 32768 => NSEventMaskApplicationDefined, + 65536 => NSEventMaskPeriodic, + 131072 => NSEventMaskCursorUpdate, + 4194304 => NSEventMaskScrollWheel, + 8388608 => NSEventMaskTabletPoint, + 16777216 => NSEventMaskTabletProximity, + 33554432 => NSEventMaskOtherMouseDown, + 67108864 => NSEventMaskOtherMouseUp, + 134217728 => NSEventMaskOtherMouseDragged, + 536870912 => NSEventMaskGesture, + 1073741824 => NSEventMaskMagnify, + 2147483648 => NSEventMaskSwipe, + 262144 => NSEventMaskRotate, + 524288 => NSEventMaskBeginGesture, + 1048576 => NSEventMaskEndGesture, + 4294967296 => NSEventMaskSmartMagnify, + 17179869184 => NSEventMaskPressure, + 137438953472 => NSEventMaskDirectTouch, + 274877906944 => NSEventMaskChangeMode, + -1 => NSEventMaskAny, + _ => throw ArgumentError("Unknown value for NSEventMask: $value"), + }; +} + +late final _sel_associatedEventsMask = + objc.registerName("associatedEventsMask"); +final _objc_msgSend_91 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.LongLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum NSPressureBehavior { + NSPressureBehaviorUnknown(-1), + NSPressureBehaviorPrimaryDefault(0), + NSPressureBehaviorPrimaryClick(1), + NSPressureBehaviorPrimaryGeneric(2), + NSPressureBehaviorPrimaryAccelerator(3), + NSPressureBehaviorPrimaryDeepClick(5), + NSPressureBehaviorPrimaryDeepDrag(6); + + final int value; + const NSPressureBehavior(this.value); + + static NSPressureBehavior fromValue(int value) => switch (value) { + -1 => NSPressureBehaviorUnknown, + 0 => NSPressureBehaviorPrimaryDefault, + 1 => NSPressureBehaviorPrimaryClick, + 2 => NSPressureBehaviorPrimaryGeneric, + 3 => NSPressureBehaviorPrimaryAccelerator, + 5 => NSPressureBehaviorPrimaryDeepClick, + 6 => NSPressureBehaviorPrimaryDeepDrag, + _ => + throw ArgumentError("Unknown value for NSPressureBehavior: $value"), + }; +} + +late final _sel_pressureBehavior = objc.registerName("pressureBehavior"); +final _objc_msgSend_92 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isSwipeTrackingFromScrollEventsEnabled = + objc.registerName("isSwipeTrackingFromScrollEventsEnabled"); + +enum NSEventSwipeTrackingOptions { + NSEventSwipeTrackingLockDirection(1), + NSEventSwipeTrackingClampGestureAmount(2); + + final int value; + const NSEventSwipeTrackingOptions(this.value); + + static NSEventSwipeTrackingOptions fromValue(int value) => switch (value) { + 1 => NSEventSwipeTrackingLockDirection, + 2 => NSEventSwipeTrackingClampGestureAmount, + _ => throw ArgumentError( + "Unknown value for NSEventSwipeTrackingOptions: $value"), + }; +} + +void _ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool_fnPtrTrampoline( + ffi.Pointer block, + double arg0, + int arg1, + bool arg2, + ffi.Pointer arg3) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Double arg0, ffi.UnsignedLong arg1, + ffi.Bool arg2, ffi.Pointer arg3)>>() + .asFunction< + void Function(double, int, bool, ffi.Pointer)>()( + arg0, arg1, arg2, arg3); +void _ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool_closureTrampoline( + ffi.Pointer block, + double arg0, + int arg1, + bool arg2, + ffi.Pointer arg3) => + (objc.getBlockClosure(block) as void Function( + double, int, bool, ffi.Pointer))(arg0, arg1, arg2, arg3); + +class ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Double arg0, ffi.UnsignedLong arg1, + ffi.Bool arg2, ffi.Pointer arg3)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong, + ffi.Bool, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool.fromFunction( + void Function(double, NSEventPhase, bool, ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong, + ffi.Bool, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool_closureTrampoline) + .cast(), + (double arg0, int arg1, bool arg2, ffi.Pointer arg3) => + fn(arg0, NSEventPhase.fromValue(arg1), arg2, arg3))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool.listener( + void Function(double, NSEventPhase, bool, ffi.Pointer) fn) + : this._((objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong, + ffi.Bool, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiDouble_NSEventPhase_bool_bool_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (double arg0, int arg1, bool arg2, ffi.Pointer arg3) => + fn(arg0, NSEventPhase.fromValue(arg1), arg2, arg3)))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong, + ffi.Bool, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(double arg0, NSEventPhase arg1, bool arg2, + ffi.Pointer arg3) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Double arg0, + ffi.UnsignedLong arg1, + ffi.Bool arg2, + ffi.Pointer arg3)>>() + .asFunction< + void Function(ffi.Pointer, double, int, bool, + ffi.Pointer)>()( + pointer, arg0, arg1.value, arg2, arg3); +} + +late final _sel_trackSwipeEventWithOptions_dampenAmountThresholdMin_max_usingHandler_ = + objc.registerName( + "trackSwipeEventWithOptions:dampenAmountThresholdMin:max:usingHandler:"); +final _objc_msgSend_93 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Double, + ffi.Double, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + int, + double, + double, + ffi.Pointer)>(); +late final _sel_startPeriodicEventsAfterDelay_withPeriod_ = + objc.registerName("startPeriodicEventsAfterDelay:withPeriod:"); +final _objc_msgSend_94 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Double, ffi.Double)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, double, double)>(); +late final _sel_stopPeriodicEvents = objc.registerName("stopPeriodicEvents"); +late final _sel_mouseEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_clickCount_pressure_ = + objc.registerName( + "mouseEventWithType:location:modifierFlags:timestamp:windowNumber:context:eventNumber:clickCount:pressure:"); +final _objc_msgSend_95 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + CGPoint, + ffi.UnsignedLong, + ffi.Double, + ffi.Long, + ffi.Pointer, + ffi.Long, + ffi.Long, + ffi.Float)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + CGPoint, + int, + double, + int, + ffi.Pointer, + int, + int, + double)>(); +late final _sel_keyEventWithType_location_modifierFlags_timestamp_windowNumber_context_characters_charactersIgnoringModifiers_isARepeat_keyCode_ = + objc.registerName( + "keyEventWithType:location:modifierFlags:timestamp:windowNumber:context:characters:charactersIgnoringModifiers:isARepeat:keyCode:"); +final _objc_msgSend_96 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + CGPoint, + ffi.UnsignedLong, + ffi.Double, + ffi.Long, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.UnsignedShort)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + CGPoint, + int, + double, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool, + int)>(); +late final _sel_enterExitEventWithType_location_modifierFlags_timestamp_windowNumber_context_eventNumber_trackingNumber_userData_ = + objc.registerName( + "enterExitEventWithType:location:modifierFlags:timestamp:windowNumber:context:eventNumber:trackingNumber:userData:"); +final _objc_msgSend_97 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + CGPoint, + ffi.UnsignedLong, + ffi.Double, + ffi.Long, + ffi.Pointer, + ffi.Long, + ffi.Long, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + CGPoint, + int, + double, + int, + ffi.Pointer, + int, + int, + ffi.Pointer)>(); +late final _sel_otherEventWithType_location_modifierFlags_timestamp_windowNumber_context_subtype_data1_data2_ = + objc.registerName( + "otherEventWithType:location:modifierFlags:timestamp:windowNumber:context:subtype:data1:data2:"); +final _objc_msgSend_98 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + CGPoint, + ffi.UnsignedLong, + ffi.Double, + ffi.Long, + ffi.Pointer, + ffi.Short, + ffi.Long, + ffi.Long)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + CGPoint, + int, + double, + int, + ffi.Pointer, + int, + int, + int)>(); +late final _sel_mouseLocation = objc.registerName("mouseLocation"); +late final _sel_pressedMouseButtons = objc.registerName("pressedMouseButtons"); +late final _sel_doubleClickInterval = objc.registerName("doubleClickInterval"); +late final _sel_keyRepeatDelay = objc.registerName("keyRepeatDelay"); +late final _sel_keyRepeatInterval = objc.registerName("keyRepeatInterval"); +void _ObjCBlock_ffiVoid_NSEvent_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_NSEvent_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_NSEvent extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSEvent._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSEvent castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSEvent._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSEvent.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSEvent_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSEvent.fromFunction(void Function(NSEvent) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSEvent_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn( + NSEvent.castFromPointer(arg0, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSEvent.listener(void Function(NSEvent) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSEvent(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSEvent_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn( + NSEvent.castFromPointer(arg0, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(NSEvent arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0.pointer); +} + +late final _sel_addGlobalMonitorForEventsMatchingMask_handler_ = + objc.registerName("addGlobalMonitorForEventsMatchingMask:handler:"); +final _objc_msgSend_99 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.LongLong, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +ffi.Pointer _ObjCBlock_NSEvent_NSEvent_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()(arg0); +ffi.Pointer _ObjCBlock_NSEvent_NSEvent_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer))(arg0); + +class ObjCBlock_NSEvent_NSEvent extends objc.ObjCBlockBase { + ObjCBlock_NSEvent_NSEvent._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSEvent_NSEvent castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_NSEvent_NSEvent._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSEvent_NSEvent.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSEvent_NSEvent_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSEvent_NSEvent.fromFunction(NSEvent? Function(NSEvent) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSEvent_NSEvent_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => + fn(NSEvent.castFromPointer(arg0, retain: true, release: true)) + ?.retainAndReturnPointer() ?? + ffi.nullptr)); + static ffi.Pointer? _dartFuncTrampoline; + + NSEvent? call(NSEvent arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction Function(ffi.Pointer, ffi.Pointer)>() + (pointer, arg0.pointer) + .address == + 0 + ? null + : NSEvent.castFromPointer( + pointer.ref.invoke.cast Function(ffi.Pointer block, ffi.Pointer arg0)>>().asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>()(pointer, arg0.pointer), + retain: false, + release: true); +} + +late final _sel_addLocalMonitorForEventsMatchingMask_handler_ = + objc.registerName("addLocalMonitorForEventsMatchingMask:handler:"); +final _objc_msgSend_100 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.LongLong, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_removeMonitor_ = objc.registerName("removeMonitor:"); +final _objc_msgSend_101 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_autoscroll_ = objc.registerName("autoscroll:"); +final _objc_msgSend_102 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_adjustScroll_ = objc.registerName("adjustScroll:"); +late final _sel_scrollRect_by_ = objc.registerName("scrollRect:by:"); +final _objc_msgSend_103 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGRect, CGSize)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGRect, CGSize)>(); +late final _sel_translateRectsNeedingDisplayInRect_by_ = + objc.registerName("translateRectsNeedingDisplayInRect:by:"); +late final _sel_hitTest_ = objc.registerName("hitTest:"); +final _objc_msgSend_104 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGPoint)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGPoint)>(); +late final _sel_mouse_inRect_ = objc.registerName("mouse:inRect:"); +final _objc_msgSend_105 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer, CGPoint, CGRect)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, CGPoint, CGRect)>(); +late final _sel_viewWithTag_ = objc.registerName("viewWithTag:"); +final _objc_msgSend_106 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_tag = objc.registerName("tag"); +late final _sel_performKeyEquivalent_ = + objc.registerName("performKeyEquivalent:"); +late final _sel_acceptsFirstMouse_ = objc.registerName("acceptsFirstMouse:"); +final _objc_msgSend_107 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_shouldDelayWindowOrderingForEvent_ = + objc.registerName("shouldDelayWindowOrderingForEvent:"); +late final _sel_needsPanelToBecomeKey = + objc.registerName("needsPanelToBecomeKey"); +late final _sel_mouseDownCanMoveWindow = + objc.registerName("mouseDownCanMoveWindow"); +late final _sel_acceptsTouchEvents = objc.registerName("acceptsTouchEvents"); +late final _sel_setAcceptsTouchEvents_ = + objc.registerName("setAcceptsTouchEvents:"); +late final _sel_wantsRestingTouches = objc.registerName("wantsRestingTouches"); +late final _sel_setWantsRestingTouches_ = + objc.registerName("setWantsRestingTouches:"); + +/// CALayer +class CALayer extends objc.ObjCObjectBase { + CALayer._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [CALayer] that points to the same underlying object as [other]. + CALayer.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CALayer] that wraps the given raw object pointer. + CALayer.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CALayer]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_CALayer); + } +} + +late final _class_CALayer = objc.getClass("CALayer"); +late final _sel_makeBackingLayer = objc.registerName("makeBackingLayer"); +final _objc_msgSend_108 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +enum NSViewLayerContentsRedrawPolicy { + NSViewLayerContentsRedrawNever(0), + NSViewLayerContentsRedrawOnSetNeedsDisplay(1), + NSViewLayerContentsRedrawDuringViewResize(2), + NSViewLayerContentsRedrawBeforeViewResize(3), + NSViewLayerContentsRedrawCrossfade(4); + + final int value; + const NSViewLayerContentsRedrawPolicy(this.value); + + static NSViewLayerContentsRedrawPolicy fromValue(int value) => + switch (value) { + 0 => NSViewLayerContentsRedrawNever, + 1 => NSViewLayerContentsRedrawOnSetNeedsDisplay, + 2 => NSViewLayerContentsRedrawDuringViewResize, + 3 => NSViewLayerContentsRedrawBeforeViewResize, + 4 => NSViewLayerContentsRedrawCrossfade, + _ => throw ArgumentError( + "Unknown value for NSViewLayerContentsRedrawPolicy: $value"), + }; +} + +late final _sel_layerContentsRedrawPolicy = + objc.registerName("layerContentsRedrawPolicy"); +final _objc_msgSend_109 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setLayerContentsRedrawPolicy_ = + objc.registerName("setLayerContentsRedrawPolicy:"); +final _objc_msgSend_110 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +enum NSViewLayerContentsPlacement { + NSViewLayerContentsPlacementScaleAxesIndependently(0), + NSViewLayerContentsPlacementScaleProportionallyToFit(1), + NSViewLayerContentsPlacementScaleProportionallyToFill(2), + NSViewLayerContentsPlacementCenter(3), + NSViewLayerContentsPlacementTop(4), + NSViewLayerContentsPlacementTopRight(5), + NSViewLayerContentsPlacementRight(6), + NSViewLayerContentsPlacementBottomRight(7), + NSViewLayerContentsPlacementBottom(8), + NSViewLayerContentsPlacementBottomLeft(9), + NSViewLayerContentsPlacementLeft(10), + NSViewLayerContentsPlacementTopLeft(11); + + final int value; + const NSViewLayerContentsPlacement(this.value); + + static NSViewLayerContentsPlacement fromValue(int value) => switch (value) { + 0 => NSViewLayerContentsPlacementScaleAxesIndependently, + 1 => NSViewLayerContentsPlacementScaleProportionallyToFit, + 2 => NSViewLayerContentsPlacementScaleProportionallyToFill, + 3 => NSViewLayerContentsPlacementCenter, + 4 => NSViewLayerContentsPlacementTop, + 5 => NSViewLayerContentsPlacementTopRight, + 6 => NSViewLayerContentsPlacementRight, + 7 => NSViewLayerContentsPlacementBottomRight, + 8 => NSViewLayerContentsPlacementBottom, + 9 => NSViewLayerContentsPlacementBottomLeft, + 10 => NSViewLayerContentsPlacementLeft, + 11 => NSViewLayerContentsPlacementTopLeft, + _ => throw ArgumentError( + "Unknown value for NSViewLayerContentsPlacement: $value"), + }; +} + +late final _sel_layerContentsPlacement = + objc.registerName("layerContentsPlacement"); +final _objc_msgSend_111 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setLayerContentsPlacement_ = + objc.registerName("setLayerContentsPlacement:"); +final _objc_msgSend_112 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_wantsLayer = objc.registerName("wantsLayer"); +late final _sel_setWantsLayer_ = objc.registerName("setWantsLayer:"); +late final _sel_layer = objc.registerName("layer"); +final _objc_msgSend_113 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setLayer_ = objc.registerName("setLayer:"); +final _objc_msgSend_114 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_wantsUpdateLayer = objc.registerName("wantsUpdateLayer"); +late final _sel_updateLayer = objc.registerName("updateLayer"); +late final _sel_canDrawSubviewsIntoLayer = + objc.registerName("canDrawSubviewsIntoLayer"); +late final _sel_setCanDrawSubviewsIntoLayer_ = + objc.registerName("setCanDrawSubviewsIntoLayer:"); +late final _sel_layoutSubtreeIfNeeded = + objc.registerName("layoutSubtreeIfNeeded"); +late final _sel_layout = objc.registerName("layout"); +late final _sel_needsLayout = objc.registerName("needsLayout"); +late final _sel_setNeedsLayout_ = objc.registerName("setNeedsLayout:"); +late final _sel_alphaValue = objc.registerName("alphaValue"); +late final _sel_setAlphaValue_ = objc.registerName("setAlphaValue:"); +late final _sel_layerUsesCoreImageFilters = + objc.registerName("layerUsesCoreImageFilters"); +late final _sel_setLayerUsesCoreImageFilters_ = + objc.registerName("setLayerUsesCoreImageFilters:"); +late final _sel_backgroundFilters = objc.registerName("backgroundFilters"); +late final _sel_setBackgroundFilters_ = + objc.registerName("setBackgroundFilters:"); + +/// CIFilter +class CIFilter extends objc.ObjCObjectBase { + CIFilter._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [CIFilter] that points to the same underlying object as [other]. + CIFilter.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CIFilter] that wraps the given raw object pointer. + CIFilter.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CIFilter]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_CIFilter); + } +} + +late final _class_CIFilter = objc.getClass("CIFilter"); +late final _sel_compositingFilter = objc.registerName("compositingFilter"); +final _objc_msgSend_115 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setCompositingFilter_ = + objc.registerName("setCompositingFilter:"); +final _objc_msgSend_116 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_contentFilters = objc.registerName("contentFilters"); +late final _sel_setContentFilters_ = objc.registerName("setContentFilters:"); + +/// NSShadow +class NSShadow extends objc.ObjCObjectBase { + NSShadow._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSShadow] that points to the same underlying object as [other]. + NSShadow.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSShadow] that wraps the given raw object pointer. + NSShadow.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSShadow]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSShadow); + } +} + +late final _class_NSShadow = objc.getClass("NSShadow"); +late final _sel_shadow = objc.registerName("shadow"); +final _objc_msgSend_117 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setShadow_ = objc.registerName("setShadow:"); +final _objc_msgSend_118 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_clipsToBounds = objc.registerName("clipsToBounds"); +late final _sel_setClipsToBounds_ = objc.registerName("setClipsToBounds:"); +late final _sel_postsBoundsChangedNotifications = + objc.registerName("postsBoundsChangedNotifications"); +late final _sel_setPostsBoundsChangedNotifications_ = + objc.registerName("setPostsBoundsChangedNotifications:"); + +/// NSScrollView +class NSScrollView extends objc.ObjCObjectBase { + NSScrollView._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSScrollView] that points to the same underlying object as [other]. + NSScrollView.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSScrollView] that wraps the given raw object pointer. + NSScrollView.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSScrollView]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSScrollView); + } +} + +late final _class_NSScrollView = objc.getClass("NSScrollView"); +late final _sel_enclosingScrollView = objc.registerName("enclosingScrollView"); +final _objc_msgSend_119 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSMenu +class NSMenu extends objc.NSObject { + NSMenu._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSMenu] that points to the same underlying object as [other]. + NSMenu.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSMenu] that wraps the given raw object pointer. + NSMenu.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSMenu]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSMenu); + } + + /// initWithTitle: + NSMenu initWithTitle_(objc.NSString title) { + final _ret = + _objc_msgSend_120(this.pointer, _sel_initWithTitle_, title.pointer); + return NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + NSMenu initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_12(this.pointer, _sel_initWithCoder_, coder.pointer); + return NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// title + objc.NSString get title { + final _ret = _objc_msgSend_13(this.pointer, _sel_title); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTitle: + set title(objc.NSString value) { + return _objc_msgSend_14(this.pointer, _sel_setTitle_, value.pointer); + } + + /// popUpContextMenu:withEvent:forView: + static void popUpContextMenu_withEvent_forView_( + NSMenu menu, NSEvent event, NSView view) { + _objc_msgSend_121(_class_NSMenu, _sel_popUpContextMenu_withEvent_forView_, + menu.pointer, event.pointer, view.pointer); + } + + /// popUpContextMenu:withEvent:forView:withFont: + static void popUpContextMenu_withEvent_forView_withFont_( + NSMenu menu, NSEvent event, NSView view, NSFont? font) { + _objc_msgSend_122( + _class_NSMenu, + _sel_popUpContextMenu_withEvent_forView_withFont_, + menu.pointer, + event.pointer, + view.pointer, + font?.pointer ?? ffi.nullptr); + } + + /// popUpMenuPositioningItem:atLocation:inView: + bool popUpMenuPositioningItem_atLocation_inView_( + NSMenuItem? item, CGPoint location, NSView? view) { + return _objc_msgSend_143( + this.pointer, + _sel_popUpMenuPositioningItem_atLocation_inView_, + item?.pointer ?? ffi.nullptr, + location, + view?.pointer ?? ffi.nullptr); + } + + /// setMenuBarVisible: + static void setMenuBarVisible_(bool visible) { + _objc_msgSend_144(_class_NSMenu, _sel_setMenuBarVisible_, visible); + } + + /// menuBarVisible + static bool menuBarVisible() { + return _objc_msgSend_17(_class_NSMenu, _sel_menuBarVisible); + } + + /// supermenu + NSMenu? get supermenu { + final _ret = _objc_msgSend_125(this.pointer, _sel_supermenu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// setSupermenu: + set supermenu(NSMenu? value) { + return _objc_msgSend_126( + this.pointer, _sel_setSupermenu_, value?.pointer ?? ffi.nullptr); + } + + /// insertItem:atIndex: + void insertItem_atIndex_(NSMenuItem newItem, int index) { + _objc_msgSend_145( + this.pointer, _sel_insertItem_atIndex_, newItem.pointer, index); + } + + /// addItem: + void addItem_(NSMenuItem newItem) { + _objc_msgSend_146(this.pointer, _sel_addItem_, newItem.pointer); + } + + /// insertItemWithTitle:action:keyEquivalent:atIndex: + NSMenuItem insertItemWithTitle_action_keyEquivalent_atIndex_( + objc.NSString string, + ffi.Pointer selector, + objc.NSString charCode, + int index) { + final _ret = _objc_msgSend_147( + this.pointer, + _sel_insertItemWithTitle_action_keyEquivalent_atIndex_, + string.pointer, + selector, + charCode.pointer, + index); + return NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// addItemWithTitle:action:keyEquivalent: + NSMenuItem addItemWithTitle_action_keyEquivalent_(objc.NSString string, + ffi.Pointer selector, objc.NSString charCode) { + final _ret = _objc_msgSend_148( + this.pointer, + _sel_addItemWithTitle_action_keyEquivalent_, + string.pointer, + selector, + charCode.pointer); + return NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// removeItemAtIndex: + void removeItemAtIndex_(int index) { + _objc_msgSend_26(this.pointer, _sel_removeItemAtIndex_, index); + } + + /// removeItem: + void removeItem_(NSMenuItem item) { + _objc_msgSend_146(this.pointer, _sel_removeItem_, item.pointer); + } + + /// setSubmenu:forItem: + void setSubmenu_forItem_(NSMenu? menu, NSMenuItem item) { + _objc_msgSend_149(this.pointer, _sel_setSubmenu_forItem_, + menu?.pointer ?? ffi.nullptr, item.pointer); + } + + /// removeAllItems + void removeAllItems() { + _objc_msgSend_5(this.pointer, _sel_removeAllItems); + } + + /// itemArray + objc.ObjCObjectBase get itemArray { + final _ret = _objc_msgSend_34(this.pointer, _sel_itemArray); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setItemArray: + set itemArray(objc.ObjCObjectBase value) { + return _objc_msgSend_35(this.pointer, _sel_setItemArray_, value.pointer); + } + + /// numberOfItems + int get numberOfItems { + return _objc_msgSend_67(this.pointer, _sel_numberOfItems); + } + + /// itemAtIndex: + NSMenuItem? itemAtIndex_(int index) { + final _ret = _objc_msgSend_150(this.pointer, _sel_itemAtIndex_, index); + return _ret.address == 0 + ? null + : NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// indexOfItem: + int indexOfItem_(NSMenuItem item) { + return _objc_msgSend_151(this.pointer, _sel_indexOfItem_, item.pointer); + } + + /// indexOfItemWithTitle: + int indexOfItemWithTitle_(objc.NSString title) { + return _objc_msgSend_152( + this.pointer, _sel_indexOfItemWithTitle_, title.pointer); + } + + /// indexOfItemWithTag: + int indexOfItemWithTag_(int tag) { + return _objc_msgSend_153(this.pointer, _sel_indexOfItemWithTag_, tag); + } + + /// indexOfItemWithRepresentedObject: + int indexOfItemWithRepresentedObject_(objc.ObjCObjectBase? object) { + return _objc_msgSend_154(this.pointer, + _sel_indexOfItemWithRepresentedObject_, object?.pointer ?? ffi.nullptr); + } + + /// indexOfItemWithSubmenu: + int indexOfItemWithSubmenu_(NSMenu? submenu) { + return _objc_msgSend_155(this.pointer, _sel_indexOfItemWithSubmenu_, + submenu?.pointer ?? ffi.nullptr); + } + + /// indexOfItemWithTarget:andAction: + int indexOfItemWithTarget_andAction_(objc.ObjCObjectBase? target, + ffi.Pointer actionSelector) { + return _objc_msgSend_156( + this.pointer, + _sel_indexOfItemWithTarget_andAction_, + target?.pointer ?? ffi.nullptr, + actionSelector); + } + + /// itemWithTitle: + NSMenuItem? itemWithTitle_(objc.NSString title) { + final _ret = + _objc_msgSend_157(this.pointer, _sel_itemWithTitle_, title.pointer); + return _ret.address == 0 + ? null + : NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// itemWithTag: + NSMenuItem? itemWithTag_(int tag) { + final _ret = _objc_msgSend_150(this.pointer, _sel_itemWithTag_, tag); + return _ret.address == 0 + ? null + : NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// autoenablesItems + bool get autoenablesItems { + return _objc_msgSend_17(this.pointer, _sel_autoenablesItems); + } + + /// setAutoenablesItems: + set autoenablesItems(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setAutoenablesItems_, value); + } + + /// update + void update() { + _objc_msgSend_5(this.pointer, _sel_update); + } + + /// performKeyEquivalent: + bool performKeyEquivalent_(NSEvent event) { + return _objc_msgSend_102( + this.pointer, _sel_performKeyEquivalent_, event.pointer); + } + + /// itemChanged: + void itemChanged_(NSMenuItem item) { + _objc_msgSend_146(this.pointer, _sel_itemChanged_, item.pointer); + } + + /// performActionForItemAtIndex: + void performActionForItemAtIndex_(int index) { + _objc_msgSend_26(this.pointer, _sel_performActionForItemAtIndex_, index); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// menuBarHeight + double get menuBarHeight { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_menuBarHeight) + : _objc_msgSend_51(this.pointer, _sel_menuBarHeight); + } + + /// cancelTracking + void cancelTracking() { + _objc_msgSend_5(this.pointer, _sel_cancelTracking); + } + + /// cancelTrackingWithoutAnimation + void cancelTrackingWithoutAnimation() { + _objc_msgSend_5(this.pointer, _sel_cancelTrackingWithoutAnimation); + } + + /// highlightedItem + NSMenuItem? get highlightedItem { + final _ret = _objc_msgSend_127(this.pointer, _sel_highlightedItem); + return _ret.address == 0 + ? null + : NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// minimumWidth + double get minimumWidth { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_minimumWidth) + : _objc_msgSend_51(this.pointer, _sel_minimumWidth); + } + + /// setMinimumWidth: + set minimumWidth(double value) { + return _objc_msgSend_52(this.pointer, _sel_setMinimumWidth_, value); + } + + /// size + void getSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_size) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_size); + } + + /// font + NSFont get font { + final _ret = _objc_msgSend_158(this.pointer, _sel_font); + return NSFont.castFromPointer(_ret, retain: true, release: true); + } + + /// setFont: + set font(NSFont value) { + return _objc_msgSend_159(this.pointer, _sel_setFont_, value.pointer); + } + + /// allowsContextMenuPlugIns + bool get allowsContextMenuPlugIns { + return _objc_msgSend_17(this.pointer, _sel_allowsContextMenuPlugIns); + } + + /// setAllowsContextMenuPlugIns: + set allowsContextMenuPlugIns(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setAllowsContextMenuPlugIns_, value); + } + + /// showsStateColumn + bool get showsStateColumn { + return _objc_msgSend_17(this.pointer, _sel_showsStateColumn); + } + + /// setShowsStateColumn: + set showsStateColumn(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setShowsStateColumn_, value); + } + + /// userInterfaceLayoutDirection + NSUserInterfaceLayoutDirection get userInterfaceLayoutDirection { + final _ret = + _objc_msgSend_160(this.pointer, _sel_userInterfaceLayoutDirection); + return NSUserInterfaceLayoutDirection.fromValue(_ret); + } + + /// setUserInterfaceLayoutDirection: + set userInterfaceLayoutDirection(NSUserInterfaceLayoutDirection value) { + return _objc_msgSend_161( + this.pointer, _sel_setUserInterfaceLayoutDirection_, value.value); + } + + /// init + NSMenu init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSMenu new1() { + final _ret = _objc_msgSend_34(_class_NSMenu, _sel_new); + return NSMenu.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSMenu allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSMenu, _sel_allocWithZone_, zone); + return NSMenu.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSMenu alloc() { + final _ret = _objc_msgSend_34(_class_NSMenu, _sel_alloc); + return NSMenu.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSMenu = objc.getClass("NSMenu"); +late final _sel_initWithTitle_ = objc.registerName("initWithTitle:"); +final _objc_msgSend_120 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_popUpContextMenu_withEvent_forView_ = + objc.registerName("popUpContextMenu:withEvent:forView:"); +final _objc_msgSend_121 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSFont +class NSFont extends objc.ObjCObjectBase { + NSFont._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSFont] that points to the same underlying object as [other]. + NSFont.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSFont] that wraps the given raw object pointer. + NSFont.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSFont]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSFont); + } +} + +late final _class_NSFont = objc.getClass("NSFont"); +late final _sel_popUpContextMenu_withEvent_forView_withFont_ = + objc.registerName("popUpContextMenu:withEvent:forView:withFont:"); +final _objc_msgSend_122 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSMenuItem +class NSMenuItem extends objc.NSObject { + NSMenuItem._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSMenuItem] that points to the same underlying object as [other]. + NSMenuItem.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSMenuItem] that wraps the given raw object pointer. + NSMenuItem.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSMenuItem]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSMenuItem); + } + + /// usesUserKeyEquivalents + static bool getUsesUserKeyEquivalents() { + return _objc_msgSend_17(_class_NSMenuItem, _sel_usesUserKeyEquivalents); + } + + /// setUsesUserKeyEquivalents: + static void setUsesUserKeyEquivalents(bool value) { + return _objc_msgSend_18( + _class_NSMenuItem, _sel_setUsesUserKeyEquivalents_, value); + } + + /// separatorItem + static NSMenuItem separatorItem() { + final _ret = _objc_msgSend_123(_class_NSMenuItem, _sel_separatorItem); + return NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// sectionHeaderWithTitle: + static NSMenuItem sectionHeaderWithTitle_(objc.NSString title) { + final _ret = _objc_msgSend_120( + _class_NSMenuItem, _sel_sectionHeaderWithTitle_, title.pointer); + return NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithTitle:action:keyEquivalent: + NSMenuItem initWithTitle_action_keyEquivalent_(objc.NSString string, + ffi.Pointer selector, objc.NSString charCode) { + final _ret = _objc_msgSend_124( + this.pointer, + _sel_initWithTitle_action_keyEquivalent_, + string.pointer, + selector, + charCode.pointer); + return NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + NSMenuItem initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_12(this.pointer, _sel_initWithCoder_, coder.pointer); + return NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// menu + NSMenu? get menu { + final _ret = _objc_msgSend_125(this.pointer, _sel_menu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// setMenu: + set menu(NSMenu? value) { + return _objc_msgSend_126( + this.pointer, _sel_setMenu_, value?.pointer ?? ffi.nullptr); + } + + /// hasSubmenu + bool get hasSubmenu { + return _objc_msgSend_17(this.pointer, _sel_hasSubmenu); + } + + /// submenu + NSMenu? get submenu { + final _ret = _objc_msgSend_125(this.pointer, _sel_submenu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// setSubmenu: + set submenu(NSMenu? value) { + return _objc_msgSend_126( + this.pointer, _sel_setSubmenu_, value?.pointer ?? ffi.nullptr); + } + + /// parentItem + NSMenuItem? get parentItem { + final _ret = _objc_msgSend_127(this.pointer, _sel_parentItem); + return _ret.address == 0 + ? null + : NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// title + objc.NSString get title { + final _ret = _objc_msgSend_13(this.pointer, _sel_title); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTitle: + set title(objc.NSString value) { + return _objc_msgSend_14(this.pointer, _sel_setTitle_, value.pointer); + } + + /// attributedTitle + NSAttributedString? get attributedTitle { + final _ret = _objc_msgSend_129(this.pointer, _sel_attributedTitle); + return _ret.address == 0 + ? null + : NSAttributedString.castFromPointer(_ret, retain: true, release: true); + } + + /// setAttributedTitle: + set attributedTitle(NSAttributedString? value) { + return _objc_msgSend_130( + this.pointer, _sel_setAttributedTitle_, value?.pointer ?? ffi.nullptr); + } + + /// isSeparatorItem + bool get separatorItem1 { + return _objc_msgSend_17(this.pointer, _sel_isSeparatorItem); + } + + /// isSectionHeader + bool get sectionHeader { + return _objc_msgSend_17(this.pointer, _sel_isSectionHeader); + } + + /// keyEquivalent + objc.NSString get keyEquivalent { + final _ret = _objc_msgSend_13(this.pointer, _sel_keyEquivalent); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setKeyEquivalent: + set keyEquivalent(objc.NSString value) { + return _objc_msgSend_14( + this.pointer, _sel_setKeyEquivalent_, value.pointer); + } + + /// keyEquivalentModifierMask + NSEventModifierFlags get keyEquivalentModifierMask { + final _ret = _objc_msgSend_66(this.pointer, _sel_keyEquivalentModifierMask); + return NSEventModifierFlags.fromValue(_ret); + } + + /// setKeyEquivalentModifierMask: + set keyEquivalentModifierMask(NSEventModifierFlags value) { + return _objc_msgSend_131( + this.pointer, _sel_setKeyEquivalentModifierMask_, value.value); + } + + /// userKeyEquivalent + objc.NSString get userKeyEquivalent { + final _ret = _objc_msgSend_13(this.pointer, _sel_userKeyEquivalent); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// allowsKeyEquivalentWhenHidden + bool get allowsKeyEquivalentWhenHidden { + return _objc_msgSend_17(this.pointer, _sel_allowsKeyEquivalentWhenHidden); + } + + /// setAllowsKeyEquivalentWhenHidden: + set allowsKeyEquivalentWhenHidden(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setAllowsKeyEquivalentWhenHidden_, value); + } + + /// allowsAutomaticKeyEquivalentLocalization + bool get allowsAutomaticKeyEquivalentLocalization { + return _objc_msgSend_17( + this.pointer, _sel_allowsAutomaticKeyEquivalentLocalization); + } + + /// setAllowsAutomaticKeyEquivalentLocalization: + set allowsAutomaticKeyEquivalentLocalization(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setAllowsAutomaticKeyEquivalentLocalization_, value); + } + + /// allowsAutomaticKeyEquivalentMirroring + bool get allowsAutomaticKeyEquivalentMirroring { + return _objc_msgSend_17( + this.pointer, _sel_allowsAutomaticKeyEquivalentMirroring); + } + + /// setAllowsAutomaticKeyEquivalentMirroring: + set allowsAutomaticKeyEquivalentMirroring(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setAllowsAutomaticKeyEquivalentMirroring_, value); + } + + /// image + NSImage? get image { + final _ret = _objc_msgSend_132(this.pointer, _sel_image); + return _ret.address == 0 + ? null + : NSImage.castFromPointer(_ret, retain: true, release: true); + } + + /// setImage: + set image(NSImage? value) { + return _objc_msgSend_133( + this.pointer, _sel_setImage_, value?.pointer ?? ffi.nullptr); + } + + /// state + int get state { + return _objc_msgSend_67(this.pointer, _sel_state); + } + + /// setState: + set state(int value) { + return _objc_msgSend_134(this.pointer, _sel_setState_, value); + } + + /// onStateImage + NSImage get onStateImage { + final _ret = _objc_msgSend_135(this.pointer, _sel_onStateImage); + return NSImage.castFromPointer(_ret, retain: true, release: true); + } + + /// setOnStateImage: + set onStateImage(NSImage value) { + return _objc_msgSend_136( + this.pointer, _sel_setOnStateImage_, value.pointer); + } + + /// offStateImage + NSImage? get offStateImage { + final _ret = _objc_msgSend_132(this.pointer, _sel_offStateImage); + return _ret.address == 0 + ? null + : NSImage.castFromPointer(_ret, retain: true, release: true); + } + + /// setOffStateImage: + set offStateImage(NSImage? value) { + return _objc_msgSend_133( + this.pointer, _sel_setOffStateImage_, value?.pointer ?? ffi.nullptr); + } + + /// mixedStateImage + NSImage get mixedStateImage { + final _ret = _objc_msgSend_135(this.pointer, _sel_mixedStateImage); + return NSImage.castFromPointer(_ret, retain: true, release: true); + } + + /// setMixedStateImage: + set mixedStateImage(NSImage value) { + return _objc_msgSend_136( + this.pointer, _sel_setMixedStateImage_, value.pointer); + } + + /// isEnabled + bool get enabled { + return _objc_msgSend_17(this.pointer, _sel_isEnabled); + } + + /// setEnabled: + set enabled(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setEnabled_, value); + } + + /// isAlternate + bool get alternate { + return _objc_msgSend_17(this.pointer, _sel_isAlternate); + } + + /// setAlternate: + set alternate(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setAlternate_, value); + } + + /// indentationLevel + int get indentationLevel { + return _objc_msgSend_67(this.pointer, _sel_indentationLevel); + } + + /// setIndentationLevel: + set indentationLevel(int value) { + return _objc_msgSend_134(this.pointer, _sel_setIndentationLevel_, value); + } + + /// target + objc.ObjCObjectBase? get target { + final _ret = _objc_msgSend_2(this.pointer, _sel_target); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setTarget: + set target(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setTarget_, value?.pointer ?? ffi.nullptr); + } + + /// action + ffi.Pointer get action { + return _objc_msgSend_137(this.pointer, _sel_action); + } + + /// setAction: + set action(ffi.Pointer value) { + return _objc_msgSend_138(this.pointer, _sel_setAction_, value); + } + + /// tag + int get tag { + return _objc_msgSend_67(this.pointer, _sel_tag); + } + + /// setTag: + set tag(int value) { + return _objc_msgSend_134(this.pointer, _sel_setTag_, value); + } + + /// representedObject + objc.ObjCObjectBase? get representedObject { + final _ret = _objc_msgSend_2(this.pointer, _sel_representedObject); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setRepresentedObject: + set representedObject(objc.ObjCObjectBase? value) { + return _objc_msgSend_3(this.pointer, _sel_setRepresentedObject_, + value?.pointer ?? ffi.nullptr); + } + + /// view + NSView? get view { + final _ret = _objc_msgSend_33(this.pointer, _sel_view); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// setView: + set view(NSView? value) { + return _objc_msgSend_139( + this.pointer, _sel_setView_, value?.pointer ?? ffi.nullptr); + } + + /// isHighlighted + bool get highlighted { + return _objc_msgSend_17(this.pointer, _sel_isHighlighted); + } + + /// isHidden + bool get hidden { + return _objc_msgSend_17(this.pointer, _sel_isHidden); + } + + /// setHidden: + set hidden(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setHidden_, value); + } + + /// isHiddenOrHasHiddenAncestor + bool get hiddenOrHasHiddenAncestor { + return _objc_msgSend_17(this.pointer, _sel_isHiddenOrHasHiddenAncestor); + } + + /// toolTip + objc.NSString? get toolTip { + final _ret = _objc_msgSend_72(this.pointer, _sel_toolTip); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setToolTip: + set toolTip(objc.NSString? value) { + return _objc_msgSend_140( + this.pointer, _sel_setToolTip_, value?.pointer ?? ffi.nullptr); + } + + /// badge + NSMenuItemBadge? get badge { + final _ret = _objc_msgSend_141(this.pointer, _sel_badge); + return _ret.address == 0 + ? null + : NSMenuItemBadge.castFromPointer(_ret, retain: true, release: true); + } + + /// setBadge: + set badge(NSMenuItemBadge? value) { + return _objc_msgSend_142( + this.pointer, _sel_setBadge_, value?.pointer ?? ffi.nullptr); + } + + /// init + NSMenuItem init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSMenuItem.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSMenuItem new1() { + final _ret = _objc_msgSend_34(_class_NSMenuItem, _sel_new); + return NSMenuItem.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSMenuItem allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSMenuItem, _sel_allocWithZone_, zone); + return NSMenuItem.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSMenuItem alloc() { + final _ret = _objc_msgSend_34(_class_NSMenuItem, _sel_alloc); + return NSMenuItem.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSMenuItem = objc.getClass("NSMenuItem"); +late final _sel_usesUserKeyEquivalents = + objc.registerName("usesUserKeyEquivalents"); +late final _sel_setUsesUserKeyEquivalents_ = + objc.registerName("setUsesUserKeyEquivalents:"); +late final _sel_separatorItem = objc.registerName("separatorItem"); +final _objc_msgSend_123 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_sectionHeaderWithTitle_ = + objc.registerName("sectionHeaderWithTitle:"); +late final _sel_initWithTitle_action_keyEquivalent_ = + objc.registerName("initWithTitle:action:keyEquivalent:"); +final _objc_msgSend_124 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_menu = objc.registerName("menu"); +final _objc_msgSend_125 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setMenu_ = objc.registerName("setMenu:"); +final _objc_msgSend_126 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_hasSubmenu = objc.registerName("hasSubmenu"); +late final _sel_submenu = objc.registerName("submenu"); +late final _sel_setSubmenu_ = objc.registerName("setSubmenu:"); +late final _sel_parentItem = objc.registerName("parentItem"); +final _objc_msgSend_127 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSAttributedString +class NSAttributedString extends objc.NSObject { + NSAttributedString._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSAttributedString] that points to the same underlying object as [other]. + NSAttributedString.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSAttributedString] that wraps the given raw object pointer. + NSAttributedString.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSAttributedString]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSAttributedString); + } + + /// string + objc.NSString get string { + final _ret = _objc_msgSend_13(this.pointer, _sel_string); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// attributesAtIndex:effectiveRange: + objc.ObjCObjectBase attributesAtIndex_effectiveRange_( + int location, ffi.Pointer<_NSRange> range) { + final _ret = _objc_msgSend_128( + this.pointer, _sel_attributesAtIndex_effectiveRange_, location, range); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// init + NSAttributedString init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSAttributedString.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static NSAttributedString new1() { + final _ret = _objc_msgSend_34(_class_NSAttributedString, _sel_new); + return NSAttributedString.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static NSAttributedString allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSAttributedString, _sel_allocWithZone_, zone); + return NSAttributedString.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static NSAttributedString alloc() { + final _ret = _objc_msgSend_34(_class_NSAttributedString, _sel_alloc); + return NSAttributedString.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_NSAttributedString = objc.getClass("NSAttributedString"); +late final _sel_string = objc.registerName("string"); + +final class _NSRange extends ffi.Struct { + @ffi.UnsignedLong() + external int location; + + @ffi.UnsignedLong() + external int length; +} + +late final _sel_attributesAtIndex_effectiveRange_ = + objc.registerName("attributesAtIndex:effectiveRange:"); +final _objc_msgSend_128 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer<_NSRange>)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int, ffi.Pointer<_NSRange>)>(); +late final _sel_attributedTitle = objc.registerName("attributedTitle"); +final _objc_msgSend_129 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAttributedTitle_ = objc.registerName("setAttributedTitle:"); +final _objc_msgSend_130 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isSeparatorItem = objc.registerName("isSeparatorItem"); +late final _sel_isSectionHeader = objc.registerName("isSectionHeader"); +late final _sel_keyEquivalent = objc.registerName("keyEquivalent"); +late final _sel_setKeyEquivalent_ = objc.registerName("setKeyEquivalent:"); +late final _sel_keyEquivalentModifierMask = + objc.registerName("keyEquivalentModifierMask"); +late final _sel_setKeyEquivalentModifierMask_ = + objc.registerName("setKeyEquivalentModifierMask:"); +final _objc_msgSend_131 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_userKeyEquivalent = objc.registerName("userKeyEquivalent"); +late final _sel_allowsKeyEquivalentWhenHidden = + objc.registerName("allowsKeyEquivalentWhenHidden"); +late final _sel_setAllowsKeyEquivalentWhenHidden_ = + objc.registerName("setAllowsKeyEquivalentWhenHidden:"); +late final _sel_allowsAutomaticKeyEquivalentLocalization = + objc.registerName("allowsAutomaticKeyEquivalentLocalization"); +late final _sel_setAllowsAutomaticKeyEquivalentLocalization_ = + objc.registerName("setAllowsAutomaticKeyEquivalentLocalization:"); +late final _sel_allowsAutomaticKeyEquivalentMirroring = + objc.registerName("allowsAutomaticKeyEquivalentMirroring"); +late final _sel_setAllowsAutomaticKeyEquivalentMirroring_ = + objc.registerName("setAllowsAutomaticKeyEquivalentMirroring:"); + +/// NSImage +class NSImage extends objc.ObjCObjectBase { + NSImage._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSImage] that points to the same underlying object as [other]. + NSImage.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSImage] that wraps the given raw object pointer. + NSImage.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSImage]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSImage); + } +} + +late final _class_NSImage = objc.getClass("NSImage"); +late final _sel_image = objc.registerName("image"); +final _objc_msgSend_132 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setImage_ = objc.registerName("setImage:"); +final _objc_msgSend_133 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_state = objc.registerName("state"); +late final _sel_setState_ = objc.registerName("setState:"); +final _objc_msgSend_134 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_onStateImage = objc.registerName("onStateImage"); +final _objc_msgSend_135 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setOnStateImage_ = objc.registerName("setOnStateImage:"); +final _objc_msgSend_136 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_offStateImage = objc.registerName("offStateImage"); +late final _sel_setOffStateImage_ = objc.registerName("setOffStateImage:"); +late final _sel_mixedStateImage = objc.registerName("mixedStateImage"); +late final _sel_setMixedStateImage_ = objc.registerName("setMixedStateImage:"); +late final _sel_isEnabled = objc.registerName("isEnabled"); +late final _sel_setEnabled_ = objc.registerName("setEnabled:"); +late final _sel_isAlternate = objc.registerName("isAlternate"); +late final _sel_setAlternate_ = objc.registerName("setAlternate:"); +late final _sel_indentationLevel = objc.registerName("indentationLevel"); +late final _sel_setIndentationLevel_ = + objc.registerName("setIndentationLevel:"); +late final _sel_target = objc.registerName("target"); +late final _sel_setTarget_ = objc.registerName("setTarget:"); +late final _sel_action = objc.registerName("action"); +final _objc_msgSend_137 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAction_ = objc.registerName("setAction:"); +final _objc_msgSend_138 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setTag_ = objc.registerName("setTag:"); +late final _sel_representedObject = objc.registerName("representedObject"); +late final _sel_setRepresentedObject_ = + objc.registerName("setRepresentedObject:"); +late final _sel_view = objc.registerName("view"); +late final _sel_setView_ = objc.registerName("setView:"); +final _objc_msgSend_139 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isHighlighted = objc.registerName("isHighlighted"); +late final _sel_toolTip = objc.registerName("toolTip"); +late final _sel_setToolTip_ = objc.registerName("setToolTip:"); +final _objc_msgSend_140 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// NSMenuItemBadge +class NSMenuItemBadge extends objc.ObjCObjectBase { + NSMenuItemBadge._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSMenuItemBadge] that points to the same underlying object as [other]. + NSMenuItemBadge.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSMenuItemBadge] that wraps the given raw object pointer. + NSMenuItemBadge.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSMenuItemBadge]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSMenuItemBadge); + } +} + +late final _class_NSMenuItemBadge = objc.getClass("NSMenuItemBadge"); +late final _sel_badge = objc.registerName("badge"); +final _objc_msgSend_141 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setBadge_ = objc.registerName("setBadge:"); +final _objc_msgSend_142 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_popUpMenuPositioningItem_atLocation_inView_ = + objc.registerName("popUpMenuPositioningItem:atLocation:inView:"); +final _objc_msgSend_143 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + ffi.Pointer)>(); +late final _sel_setMenuBarVisible_ = objc.registerName("setMenuBarVisible:"); +final _objc_msgSend_144 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, bool)>(); +late final _sel_menuBarVisible = objc.registerName("menuBarVisible"); +late final _sel_supermenu = objc.registerName("supermenu"); +late final _sel_setSupermenu_ = objc.registerName("setSupermenu:"); +late final _sel_insertItem_atIndex_ = objc.registerName("insertItem:atIndex:"); +final _objc_msgSend_145 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Long)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_addItem_ = objc.registerName("addItem:"); +final _objc_msgSend_146 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_insertItemWithTitle_action_keyEquivalent_atIndex_ = + objc.registerName("insertItemWithTitle:action:keyEquivalent:atIndex:"); +final _objc_msgSend_147 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Long)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_addItemWithTitle_action_keyEquivalent_ = + objc.registerName("addItemWithTitle:action:keyEquivalent:"); +final _objc_msgSend_148 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removeItemAtIndex_ = objc.registerName("removeItemAtIndex:"); +late final _sel_removeItem_ = objc.registerName("removeItem:"); +late final _sel_setSubmenu_forItem_ = objc.registerName("setSubmenu:forItem:"); +final _objc_msgSend_149 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removeAllItems = objc.registerName("removeAllItems"); +late final _sel_itemArray = objc.registerName("itemArray"); +late final _sel_setItemArray_ = objc.registerName("setItemArray:"); +late final _sel_numberOfItems = objc.registerName("numberOfItems"); +late final _sel_itemAtIndex_ = objc.registerName("itemAtIndex:"); +final _objc_msgSend_150 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_indexOfItem_ = objc.registerName("indexOfItem:"); +final _objc_msgSend_151 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_indexOfItemWithTitle_ = + objc.registerName("indexOfItemWithTitle:"); +final _objc_msgSend_152 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_indexOfItemWithTag_ = objc.registerName("indexOfItemWithTag:"); +final _objc_msgSend_153 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_indexOfItemWithRepresentedObject_ = + objc.registerName("indexOfItemWithRepresentedObject:"); +final _objc_msgSend_154 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_indexOfItemWithSubmenu_ = + objc.registerName("indexOfItemWithSubmenu:"); +final _objc_msgSend_155 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_indexOfItemWithTarget_andAction_ = + objc.registerName("indexOfItemWithTarget:andAction:"); +final _objc_msgSend_156 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_itemWithTitle_ = objc.registerName("itemWithTitle:"); +final _objc_msgSend_157 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_itemWithTag_ = objc.registerName("itemWithTag:"); +late final _sel_autoenablesItems = objc.registerName("autoenablesItems"); +late final _sel_setAutoenablesItems_ = + objc.registerName("setAutoenablesItems:"); +late final _sel_update = objc.registerName("update"); +late final _sel_itemChanged_ = objc.registerName("itemChanged:"); +late final _sel_performActionForItemAtIndex_ = + objc.registerName("performActionForItemAtIndex:"); +late final _sel_menuBarHeight = objc.registerName("menuBarHeight"); +late final _sel_cancelTracking = objc.registerName("cancelTracking"); +late final _sel_cancelTrackingWithoutAnimation = + objc.registerName("cancelTrackingWithoutAnimation"); +late final _sel_highlightedItem = objc.registerName("highlightedItem"); +late final _sel_minimumWidth = objc.registerName("minimumWidth"); +late final _sel_setMinimumWidth_ = objc.registerName("setMinimumWidth:"); +late final _sel_size = objc.registerName("size"); +late final _sel_font = objc.registerName("font"); +final _objc_msgSend_158 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setFont_ = objc.registerName("setFont:"); +final _objc_msgSend_159 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_allowsContextMenuPlugIns = + objc.registerName("allowsContextMenuPlugIns"); +late final _sel_setAllowsContextMenuPlugIns_ = + objc.registerName("setAllowsContextMenuPlugIns:"); +late final _sel_showsStateColumn = objc.registerName("showsStateColumn"); +late final _sel_setShowsStateColumn_ = + objc.registerName("setShowsStateColumn:"); + +enum NSUserInterfaceLayoutDirection { + NSUserInterfaceLayoutDirectionLeftToRight(0), + NSUserInterfaceLayoutDirectionRightToLeft(1); + + final int value; + const NSUserInterfaceLayoutDirection(this.value); + + static NSUserInterfaceLayoutDirection fromValue(int value) => switch (value) { + 0 => NSUserInterfaceLayoutDirectionLeftToRight, + 1 => NSUserInterfaceLayoutDirectionRightToLeft, + _ => throw ArgumentError( + "Unknown value for NSUserInterfaceLayoutDirection: $value"), + }; +} + +late final _sel_userInterfaceLayoutDirection = + objc.registerName("userInterfaceLayoutDirection"); +final _objc_msgSend_160 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setUserInterfaceLayoutDirection_ = + objc.registerName("setUserInterfaceLayoutDirection:"); +final _objc_msgSend_161 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_menuForEvent_ = objc.registerName("menuForEvent:"); +final _objc_msgSend_162 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_defaultMenu = objc.registerName("defaultMenu"); +late final _sel_willOpenMenu_withEvent_ = + objc.registerName("willOpenMenu:withEvent:"); +final _objc_msgSend_163 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_didCloseMenu_withEvent_ = + objc.registerName("didCloseMenu:withEvent:"); +final _objc_msgSend_164 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_addToolTipRect_owner_userData_ = + objc.registerName("addToolTipRect:owner:userData:"); +final _objc_msgSend_165 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removeToolTip_ = objc.registerName("removeToolTip:"); +late final _sel_removeAllToolTips = objc.registerName("removeAllToolTips"); +late final _sel_viewWillStartLiveResize = + objc.registerName("viewWillStartLiveResize"); +late final _sel_viewDidEndLiveResize = + objc.registerName("viewDidEndLiveResize"); +late final _sel_inLiveResize = objc.registerName("inLiveResize"); +late final _sel_preservesContentDuringLiveResize = + objc.registerName("preservesContentDuringLiveResize"); +late final _sel_rectPreservedDuringLiveResize = + objc.registerName("rectPreservedDuringLiveResize"); +late final _sel_getRectsExposedDuringLiveResize_count_ = + objc.registerName("getRectsExposedDuringLiveResize:count:"); +final _objc_msgSend_166 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSTextInputContext +class NSTextInputContext extends objc.ObjCObjectBase { + NSTextInputContext._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSTextInputContext] that points to the same underlying object as [other]. + NSTextInputContext.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSTextInputContext] that wraps the given raw object pointer. + NSTextInputContext.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSTextInputContext]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSTextInputContext); + } +} + +late final _class_NSTextInputContext = objc.getClass("NSTextInputContext"); +late final _sel_inputContext = objc.registerName("inputContext"); +final _objc_msgSend_167 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_rectForSmartMagnificationAtPoint_inRect_ = + objc.registerName("rectForSmartMagnificationAtPoint:inRect:"); +final _objc_msgSend_168 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer, CGPoint, CGRect)>>() + .asFunction< + CGRect Function(ffi.Pointer, + ffi.Pointer, CGPoint, CGRect)>(); +final _objc_msgSend_168Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGPoint, CGRect)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, CGPoint, CGRect)>(); +late final _sel_prepareForReuse = objc.registerName("prepareForReuse"); +late final _sel_isCompatibleWithResponsiveScrolling = + objc.registerName("isCompatibleWithResponsiveScrolling"); +late final _sel_prepareContentInRect_ = + objc.registerName("prepareContentInRect:"); +late final _sel_preparedContentRect = objc.registerName("preparedContentRect"); +late final _sel_setPreparedContentRect_ = + objc.registerName("setPreparedContentRect:"); +late final _sel_allowsVibrancy = objc.registerName("allowsVibrancy"); +late final _sel_viewDidChangeEffectiveAppearance = + objc.registerName("viewDidChangeEffectiveAppearance"); + +/// NSResponder +class NSResponder extends objc.NSObject { + NSResponder._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSResponder] that points to the same underlying object as [other]. + NSResponder.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSResponder] that wraps the given raw object pointer. + NSResponder.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSResponder]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSResponder); + } + + /// init + NSResponder init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSResponder.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + NSResponder? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_31(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : NSResponder.castFromPointer(_ret, retain: true, release: true); + } + + /// nextResponder + NSResponder? get nextResponder { + final _ret = _objc_msgSend_169(this.pointer, _sel_nextResponder); + return _ret.address == 0 + ? null + : NSResponder.castFromPointer(_ret, retain: true, release: true); + } + + /// setNextResponder: + set nextResponder(NSResponder? value) { + return _objc_msgSend_170( + this.pointer, _sel_setNextResponder_, value?.pointer ?? ffi.nullptr); + } + + /// tryToPerform:with: + bool tryToPerform_with_( + ffi.Pointer action, objc.ObjCObjectBase? object) { + return _objc_msgSend_171(this.pointer, _sel_tryToPerform_with_, action, + object?.pointer ?? ffi.nullptr); + } + + /// performKeyEquivalent: + bool performKeyEquivalent_(NSEvent event) { + return _objc_msgSend_102( + this.pointer, _sel_performKeyEquivalent_, event.pointer); + } + + /// validRequestorForSendType:returnType: + objc.ObjCObjectBase? validRequestorForSendType_returnType_( + objc.NSString? sendType, objc.NSString? returnType) { + final _ret = _objc_msgSend_172( + this.pointer, + _sel_validRequestorForSendType_returnType_, + sendType?.pointer ?? ffi.nullptr, + returnType?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// mouseDown: + void mouseDown_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_mouseDown_, event.pointer); + } + + /// rightMouseDown: + void rightMouseDown_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_rightMouseDown_, event.pointer); + } + + /// otherMouseDown: + void otherMouseDown_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_otherMouseDown_, event.pointer); + } + + /// mouseUp: + void mouseUp_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_mouseUp_, event.pointer); + } + + /// rightMouseUp: + void rightMouseUp_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_rightMouseUp_, event.pointer); + } + + /// otherMouseUp: + void otherMouseUp_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_otherMouseUp_, event.pointer); + } + + /// mouseMoved: + void mouseMoved_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_mouseMoved_, event.pointer); + } + + /// mouseDragged: + void mouseDragged_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_mouseDragged_, event.pointer); + } + + /// scrollWheel: + void scrollWheel_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_scrollWheel_, event.pointer); + } + + /// rightMouseDragged: + void rightMouseDragged_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_rightMouseDragged_, event.pointer); + } + + /// otherMouseDragged: + void otherMouseDragged_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_otherMouseDragged_, event.pointer); + } + + /// mouseEntered: + void mouseEntered_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_mouseEntered_, event.pointer); + } + + /// mouseExited: + void mouseExited_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_mouseExited_, event.pointer); + } + + /// keyDown: + void keyDown_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_keyDown_, event.pointer); + } + + /// keyUp: + void keyUp_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_keyUp_, event.pointer); + } + + /// flagsChanged: + void flagsChanged_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_flagsChanged_, event.pointer); + } + + /// tabletPoint: + void tabletPoint_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_tabletPoint_, event.pointer); + } + + /// tabletProximity: + void tabletProximity_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_tabletProximity_, event.pointer); + } + + /// cursorUpdate: + void cursorUpdate_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_cursorUpdate_, event.pointer); + } + + /// magnifyWithEvent: + void magnifyWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_magnifyWithEvent_, event.pointer); + } + + /// rotateWithEvent: + void rotateWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_rotateWithEvent_, event.pointer); + } + + /// swipeWithEvent: + void swipeWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_swipeWithEvent_, event.pointer); + } + + /// beginGestureWithEvent: + void beginGestureWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_beginGestureWithEvent_, event.pointer); + } + + /// endGestureWithEvent: + void endGestureWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_endGestureWithEvent_, event.pointer); + } + + /// smartMagnifyWithEvent: + void smartMagnifyWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_smartMagnifyWithEvent_, event.pointer); + } + + /// changeModeWithEvent: + void changeModeWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_changeModeWithEvent_, event.pointer); + } + + /// touchesBeganWithEvent: + void touchesBeganWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_touchesBeganWithEvent_, event.pointer); + } + + /// touchesMovedWithEvent: + void touchesMovedWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_touchesMovedWithEvent_, event.pointer); + } + + /// touchesEndedWithEvent: + void touchesEndedWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_touchesEndedWithEvent_, event.pointer); + } + + /// touchesCancelledWithEvent: + void touchesCancelledWithEvent_(NSEvent event) { + _objc_msgSend_173( + this.pointer, _sel_touchesCancelledWithEvent_, event.pointer); + } + + /// quickLookWithEvent: + void quickLookWithEvent_(NSEvent event) { + _objc_msgSend_173(this.pointer, _sel_quickLookWithEvent_, event.pointer); + } + + /// pressureChangeWithEvent: + void pressureChangeWithEvent_(NSEvent event) { + _objc_msgSend_173( + this.pointer, _sel_pressureChangeWithEvent_, event.pointer); + } + + /// noResponderFor: + void noResponderFor_(ffi.Pointer eventSelector) { + _objc_msgSend_174(this.pointer, _sel_noResponderFor_, eventSelector); + } + + /// acceptsFirstResponder + bool get acceptsFirstResponder { + return _objc_msgSend_17(this.pointer, _sel_acceptsFirstResponder); + } + + /// becomeFirstResponder + bool becomeFirstResponder() { + return _objc_msgSend_17(this.pointer, _sel_becomeFirstResponder); + } + + /// resignFirstResponder + bool resignFirstResponder() { + return _objc_msgSend_17(this.pointer, _sel_resignFirstResponder); + } + + /// interpretKeyEvents: + void interpretKeyEvents_(objc.ObjCObjectBase eventArray) { + _objc_msgSend_101( + this.pointer, _sel_interpretKeyEvents_, eventArray.pointer); + } + + /// flushBufferedKeyEvents + void flushBufferedKeyEvents() { + _objc_msgSend_5(this.pointer, _sel_flushBufferedKeyEvents); + } + + /// menu + NSMenu? get menu { + final _ret = _objc_msgSend_125(this.pointer, _sel_menu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// setMenu: + set menu(NSMenu? value) { + return _objc_msgSend_126( + this.pointer, _sel_setMenu_, value?.pointer ?? ffi.nullptr); + } + + /// showContextHelp: + void showContextHelp_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_showContextHelp_, sender?.pointer ?? ffi.nullptr); + } + + /// helpRequested: + void helpRequested_(NSEvent eventPtr) { + _objc_msgSend_173(this.pointer, _sel_helpRequested_, eventPtr.pointer); + } + + /// shouldBeTreatedAsInkEvent: + bool shouldBeTreatedAsInkEvent_(NSEvent event) { + return _objc_msgSend_102( + this.pointer, _sel_shouldBeTreatedAsInkEvent_, event.pointer); + } + + /// wantsScrollEventsForSwipeTrackingOnAxis: + bool wantsScrollEventsForSwipeTrackingOnAxis_(NSEventGestureAxis axis) { + return _objc_msgSend_175(this.pointer, + _sel_wantsScrollEventsForSwipeTrackingOnAxis_, axis.value); + } + + /// wantsForwardedScrollEventsForAxis: + bool wantsForwardedScrollEventsForAxis_(NSEventGestureAxis axis) { + return _objc_msgSend_175( + this.pointer, _sel_wantsForwardedScrollEventsForAxis_, axis.value); + } + + /// supplementalTargetForAction:sender: + objc.ObjCObjectBase? supplementalTargetForAction_sender_( + ffi.Pointer action, objc.ObjCObjectBase? sender) { + final _ret = _objc_msgSend_176( + this.pointer, + _sel_supplementalTargetForAction_sender_, + action, + sender?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// new + static NSResponder new1() { + final _ret = _objc_msgSend_34(_class_NSResponder, _sel_new); + return NSResponder.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSResponder allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSResponder, _sel_allocWithZone_, zone); + return NSResponder.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSResponder alloc() { + final _ret = _objc_msgSend_34(_class_NSResponder, _sel_alloc); + return NSResponder.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSResponder = objc.getClass("NSResponder"); +late final _sel_nextResponder = objc.registerName("nextResponder"); +final _objc_msgSend_169 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setNextResponder_ = objc.registerName("setNextResponder:"); +final _objc_msgSend_170 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_tryToPerform_with_ = objc.registerName("tryToPerform:with:"); +final _objc_msgSend_171 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_validRequestorForSendType_returnType_ = + objc.registerName("validRequestorForSendType:returnType:"); +final _objc_msgSend_172 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_mouseDown_ = objc.registerName("mouseDown:"); +final _objc_msgSend_173 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_rightMouseDown_ = objc.registerName("rightMouseDown:"); +late final _sel_otherMouseDown_ = objc.registerName("otherMouseDown:"); +late final _sel_mouseUp_ = objc.registerName("mouseUp:"); +late final _sel_rightMouseUp_ = objc.registerName("rightMouseUp:"); +late final _sel_otherMouseUp_ = objc.registerName("otherMouseUp:"); +late final _sel_mouseMoved_ = objc.registerName("mouseMoved:"); +late final _sel_mouseDragged_ = objc.registerName("mouseDragged:"); +late final _sel_scrollWheel_ = objc.registerName("scrollWheel:"); +late final _sel_rightMouseDragged_ = objc.registerName("rightMouseDragged:"); +late final _sel_otherMouseDragged_ = objc.registerName("otherMouseDragged:"); +late final _sel_mouseEntered_ = objc.registerName("mouseEntered:"); +late final _sel_mouseExited_ = objc.registerName("mouseExited:"); +late final _sel_keyDown_ = objc.registerName("keyDown:"); +late final _sel_keyUp_ = objc.registerName("keyUp:"); +late final _sel_flagsChanged_ = objc.registerName("flagsChanged:"); +late final _sel_tabletPoint_ = objc.registerName("tabletPoint:"); +late final _sel_tabletProximity_ = objc.registerName("tabletProximity:"); +late final _sel_cursorUpdate_ = objc.registerName("cursorUpdate:"); +late final _sel_magnifyWithEvent_ = objc.registerName("magnifyWithEvent:"); +late final _sel_rotateWithEvent_ = objc.registerName("rotateWithEvent:"); +late final _sel_swipeWithEvent_ = objc.registerName("swipeWithEvent:"); +late final _sel_beginGestureWithEvent_ = + objc.registerName("beginGestureWithEvent:"); +late final _sel_endGestureWithEvent_ = + objc.registerName("endGestureWithEvent:"); +late final _sel_smartMagnifyWithEvent_ = + objc.registerName("smartMagnifyWithEvent:"); +late final _sel_changeModeWithEvent_ = + objc.registerName("changeModeWithEvent:"); +late final _sel_touchesBeganWithEvent_ = + objc.registerName("touchesBeganWithEvent:"); +late final _sel_touchesMovedWithEvent_ = + objc.registerName("touchesMovedWithEvent:"); +late final _sel_touchesEndedWithEvent_ = + objc.registerName("touchesEndedWithEvent:"); +late final _sel_touchesCancelledWithEvent_ = + objc.registerName("touchesCancelledWithEvent:"); +late final _sel_quickLookWithEvent_ = objc.registerName("quickLookWithEvent:"); +late final _sel_pressureChangeWithEvent_ = + objc.registerName("pressureChangeWithEvent:"); +late final _sel_noResponderFor_ = objc.registerName("noResponderFor:"); +final _objc_msgSend_174 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_acceptsFirstResponder = + objc.registerName("acceptsFirstResponder"); +late final _sel_becomeFirstResponder = + objc.registerName("becomeFirstResponder"); +late final _sel_resignFirstResponder = + objc.registerName("resignFirstResponder"); +late final _sel_interpretKeyEvents_ = objc.registerName("interpretKeyEvents:"); +late final _sel_flushBufferedKeyEvents = + objc.registerName("flushBufferedKeyEvents"); +late final _sel_showContextHelp_ = objc.registerName("showContextHelp:"); +late final _sel_helpRequested_ = objc.registerName("helpRequested:"); +late final _sel_shouldBeTreatedAsInkEvent_ = + objc.registerName("shouldBeTreatedAsInkEvent:"); + +enum NSEventGestureAxis { + NSEventGestureAxisNone(0), + NSEventGestureAxisHorizontal(1), + NSEventGestureAxisVertical(2); + + final int value; + const NSEventGestureAxis(this.value); + + static NSEventGestureAxis fromValue(int value) => switch (value) { + 0 => NSEventGestureAxisNone, + 1 => NSEventGestureAxisHorizontal, + 2 => NSEventGestureAxisVertical, + _ => + throw ArgumentError("Unknown value for NSEventGestureAxis: $value"), + }; +} + +late final _sel_wantsScrollEventsForSwipeTrackingOnAxis_ = + objc.registerName("wantsScrollEventsForSwipeTrackingOnAxis:"); +final _objc_msgSend_175 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_wantsForwardedScrollEventsForAxis_ = + objc.registerName("wantsForwardedScrollEventsForAxis:"); +late final _sel_supplementalTargetForAction_sender_ = + objc.registerName("supplementalTargetForAction:sender:"); +final _objc_msgSend_176 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_contentView = objc.registerName("contentView"); +late final _sel_setContentView_ = objc.registerName("setContentView:"); +late final _sel_styleMask = objc.registerName("styleMask"); +final _objc_msgSend_177 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setStyleMask_ = objc.registerName("setStyleMask:"); +final _objc_msgSend_178 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +/// NSText +class NSText extends NSView { + NSText._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSText] that points to the same underlying object as [other]. + NSText.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSText] that wraps the given raw object pointer. + NSText.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSText]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSText); + } + + /// initWithFrame: + NSText initWithFrame_(CGRect frameRect) { + final _ret = _objc_msgSend_30(this.pointer, _sel_initWithFrame_, frameRect); + return NSText.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + NSText? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_31(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : NSText.castFromPointer(_ret, retain: true, release: true); + } + + /// string + objc.NSString get string { + final _ret = _objc_msgSend_13(this.pointer, _sel_string); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setString: + set string(objc.NSString value) { + return _objc_msgSend_14(this.pointer, _sel_setString_, value.pointer); + } + + /// replaceCharactersInRange:withString: + void replaceCharactersInRange_withString_( + _NSRange range, objc.NSString string) { + _objc_msgSend_179(this.pointer, _sel_replaceCharactersInRange_withString_, + range, string.pointer); + } + + /// replaceCharactersInRange:withRTF: + void replaceCharactersInRange_withRTF_(_NSRange range, objc.NSData rtfData) { + _objc_msgSend_180(this.pointer, _sel_replaceCharactersInRange_withRTF_, + range, rtfData.pointer); + } + + /// replaceCharactersInRange:withRTFD: + void replaceCharactersInRange_withRTFD_( + _NSRange range, objc.NSData rtfdData) { + _objc_msgSend_180(this.pointer, _sel_replaceCharactersInRange_withRTFD_, + range, rtfdData.pointer); + } + + /// RTFFromRange: + objc.NSData? RTFFromRange_(_NSRange range) { + final _ret = _objc_msgSend_181(this.pointer, _sel_RTFFromRange_, range); + return _ret.address == 0 + ? null + : objc.NSData.castFromPointer(_ret, retain: true, release: true); + } + + /// RTFDFromRange: + objc.NSData? RTFDFromRange_(_NSRange range) { + final _ret = _objc_msgSend_181(this.pointer, _sel_RTFDFromRange_, range); + return _ret.address == 0 + ? null + : objc.NSData.castFromPointer(_ret, retain: true, release: true); + } + + /// writeRTFDToFile:atomically: + bool writeRTFDToFile_atomically_(objc.NSString path, bool flag) { + return _objc_msgSend_182( + this.pointer, _sel_writeRTFDToFile_atomically_, path.pointer, flag); + } + + /// readRTFDFromFile: + bool readRTFDFromFile_(objc.NSString path) { + return _objc_msgSend_183( + this.pointer, _sel_readRTFDFromFile_, path.pointer); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// isEditable + bool get editable { + return _objc_msgSend_17(this.pointer, _sel_isEditable); + } + + /// setEditable: + set editable(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setEditable_, value); + } + + /// isSelectable + bool get selectable { + return _objc_msgSend_17(this.pointer, _sel_isSelectable); + } + + /// setSelectable: + set selectable(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setSelectable_, value); + } + + /// isRichText + bool get richText { + return _objc_msgSend_17(this.pointer, _sel_isRichText); + } + + /// setRichText: + set richText(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setRichText_, value); + } + + /// importsGraphics + bool get importsGraphics { + return _objc_msgSend_17(this.pointer, _sel_importsGraphics); + } + + /// setImportsGraphics: + set importsGraphics(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setImportsGraphics_, value); + } + + /// isFieldEditor + bool get fieldEditor { + return _objc_msgSend_17(this.pointer, _sel_isFieldEditor); + } + + /// setFieldEditor: + set fieldEditor(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setFieldEditor_, value); + } + + /// usesFontPanel + bool get usesFontPanel { + return _objc_msgSend_17(this.pointer, _sel_usesFontPanel); + } + + /// setUsesFontPanel: + set usesFontPanel(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setUsesFontPanel_, value); + } + + /// drawsBackground + bool get drawsBackground { + return _objc_msgSend_17(this.pointer, _sel_drawsBackground); + } + + /// setDrawsBackground: + set drawsBackground(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setDrawsBackground_, value); + } + + /// backgroundColor + NSColor? get backgroundColor { + final _ret = _objc_msgSend_184(this.pointer, _sel_backgroundColor); + return _ret.address == 0 + ? null + : NSColor.castFromPointer(_ret, retain: true, release: true); + } + + /// setBackgroundColor: + set backgroundColor(NSColor? value) { + return _objc_msgSend_185( + this.pointer, _sel_setBackgroundColor_, value?.pointer ?? ffi.nullptr); + } + + /// isRulerVisible + bool get rulerVisible { + return _objc_msgSend_17(this.pointer, _sel_isRulerVisible); + } + + /// selectedRange + void getSelectedRange(ffi.Pointer<_NSRange> stret) { + objc.useMsgSendVariants + ? _objc_msgSend_186Stret(stret, this.pointer, _sel_selectedRange) + : stret.ref = _objc_msgSend_186(this.pointer, _sel_selectedRange); + } + + /// setSelectedRange: + set selectedRange(_NSRange value) { + return _objc_msgSend_187(this.pointer, _sel_setSelectedRange_, value); + } + + /// scrollRangeToVisible: + void scrollRangeToVisible_(_NSRange range) { + _objc_msgSend_188(this.pointer, _sel_scrollRangeToVisible_, range); + } + + /// font + NSFont? get font { + final _ret = _objc_msgSend_189(this.pointer, _sel_font); + return _ret.address == 0 + ? null + : NSFont.castFromPointer(_ret, retain: true, release: true); + } + + /// setFont: + set font(NSFont? value) { + return _objc_msgSend_190( + this.pointer, _sel_setFont_, value?.pointer ?? ffi.nullptr); + } + + /// textColor + NSColor? get textColor { + final _ret = _objc_msgSend_184(this.pointer, _sel_textColor); + return _ret.address == 0 + ? null + : NSColor.castFromPointer(_ret, retain: true, release: true); + } + + /// setTextColor: + set textColor(NSColor? value) { + return _objc_msgSend_185( + this.pointer, _sel_setTextColor_, value?.pointer ?? ffi.nullptr); + } + + /// alignment + NSTextAlignment get alignment { + final _ret = _objc_msgSend_191(this.pointer, _sel_alignment); + return NSTextAlignment.fromValue(_ret); + } + + /// setAlignment: + set alignment(NSTextAlignment value) { + return _objc_msgSend_192(this.pointer, _sel_setAlignment_, value.value); + } + + /// baseWritingDirection + NSWritingDirection get baseWritingDirection { + final _ret = _objc_msgSend_193(this.pointer, _sel_baseWritingDirection); + return NSWritingDirection.fromValue(_ret); + } + + /// setBaseWritingDirection: + set baseWritingDirection(NSWritingDirection value) { + return _objc_msgSend_194( + this.pointer, _sel_setBaseWritingDirection_, value.value); + } + + /// setTextColor:range: + void setTextColor_range_(NSColor? color, _NSRange range) { + _objc_msgSend_195(this.pointer, _sel_setTextColor_range_, + color?.pointer ?? ffi.nullptr, range); + } + + /// setFont:range: + void setFont_range_(NSFont font, _NSRange range) { + _objc_msgSend_196(this.pointer, _sel_setFont_range_, font.pointer, range); + } + + /// maxSize + void getMaxSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_maxSize) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_maxSize); + } + + /// setMaxSize: + set maxSize(CGSize value) { + return _objc_msgSend_197(this.pointer, _sel_setMaxSize_, value); + } + + /// minSize + void getMinSize(ffi.Pointer stret) { + objc.useMsgSendVariants + ? _objc_msgSend_88Stret(stret, this.pointer, _sel_minSize) + : stret.ref = _objc_msgSend_88(this.pointer, _sel_minSize); + } + + /// setMinSize: + set minSize(CGSize value) { + return _objc_msgSend_197(this.pointer, _sel_setMinSize_, value); + } + + /// isHorizontallyResizable + bool get horizontallyResizable { + return _objc_msgSend_17(this.pointer, _sel_isHorizontallyResizable); + } + + /// setHorizontallyResizable: + set horizontallyResizable(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setHorizontallyResizable_, value); + } + + /// isVerticallyResizable + bool get verticallyResizable { + return _objc_msgSend_17(this.pointer, _sel_isVerticallyResizable); + } + + /// setVerticallyResizable: + set verticallyResizable(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setVerticallyResizable_, value); + } + + /// sizeToFit + void sizeToFit() { + _objc_msgSend_5(this.pointer, _sel_sizeToFit); + } + + /// copy: + void copy_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_copy_, sender?.pointer ?? ffi.nullptr); + } + + /// copyFont: + void copyFont_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_copyFont_, sender?.pointer ?? ffi.nullptr); + } + + /// copyRuler: + void copyRuler_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_copyRuler_, sender?.pointer ?? ffi.nullptr); + } + + /// cut: + void cut_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_cut_, sender?.pointer ?? ffi.nullptr); + } + + /// delete: + void delete_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_delete_, sender?.pointer ?? ffi.nullptr); + } + + /// paste: + void paste_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4(this.pointer, _sel_paste_, sender?.pointer ?? ffi.nullptr); + } + + /// pasteFont: + void pasteFont_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_pasteFont_, sender?.pointer ?? ffi.nullptr); + } + + /// pasteRuler: + void pasteRuler_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_pasteRuler_, sender?.pointer ?? ffi.nullptr); + } + + /// selectAll: + void selectAll_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_selectAll_, sender?.pointer ?? ffi.nullptr); + } + + /// changeFont: + void changeFont_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_changeFont_, sender?.pointer ?? ffi.nullptr); + } + + /// alignLeft: + void alignLeft_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_alignLeft_, sender?.pointer ?? ffi.nullptr); + } + + /// alignRight: + void alignRight_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_alignRight_, sender?.pointer ?? ffi.nullptr); + } + + /// alignCenter: + void alignCenter_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_alignCenter_, sender?.pointer ?? ffi.nullptr); + } + + /// subscript: + void subscript_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_subscript_, sender?.pointer ?? ffi.nullptr); + } + + /// superscript: + void superscript_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_superscript_, sender?.pointer ?? ffi.nullptr); + } + + /// underline: + void underline_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_underline_, sender?.pointer ?? ffi.nullptr); + } + + /// unscript: + void unscript_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_unscript_, sender?.pointer ?? ffi.nullptr); + } + + /// showGuessPanel: + void showGuessPanel_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_showGuessPanel_, sender?.pointer ?? ffi.nullptr); + } + + /// checkSpelling: + void checkSpelling_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_checkSpelling_, sender?.pointer ?? ffi.nullptr); + } + + /// toggleRuler: + void toggleRuler_(objc.ObjCObjectBase? sender) { + _objc_msgSend_4( + this.pointer, _sel_toggleRuler_, sender?.pointer ?? ffi.nullptr); + } + + /// focusView + static NSView? getFocusView() { + final _ret = _objc_msgSend_33(_class_NSText, _sel_focusView); + return _ret.address == 0 + ? null + : NSView.castFromPointer(_ret, retain: true, release: true); + } + + /// defaultMenu + static NSMenu? getDefaultMenu() { + final _ret = _objc_msgSend_125(_class_NSText, _sel_defaultMenu); + return _ret.address == 0 + ? null + : NSMenu.castFromPointer(_ret, retain: true, release: true); + } + + /// isCompatibleWithResponsiveScrolling + static bool getCompatibleWithResponsiveScrolling() { + return _objc_msgSend_17( + _class_NSText, _sel_isCompatibleWithResponsiveScrolling); + } + + /// init + NSText init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSText.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSText new1() { + final _ret = _objc_msgSend_34(_class_NSText, _sel_new); + return NSText.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSText allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSText, _sel_allocWithZone_, zone); + return NSText.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSText alloc() { + final _ret = _objc_msgSend_34(_class_NSText, _sel_alloc); + return NSText.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSText = objc.getClass("NSText"); +late final _sel_setString_ = objc.registerName("setString:"); +late final _sel_replaceCharactersInRange_withString_ = + objc.registerName("replaceCharactersInRange:withString:"); +final _objc_msgSend_179 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + _NSRange, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + _NSRange, + ffi.Pointer)>(); +late final _sel_replaceCharactersInRange_withRTF_ = + objc.registerName("replaceCharactersInRange:withRTF:"); +final _objc_msgSend_180 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + _NSRange, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + _NSRange, + ffi.Pointer)>(); +late final _sel_replaceCharactersInRange_withRTFD_ = + objc.registerName("replaceCharactersInRange:withRTFD:"); +late final _sel_RTFFromRange_ = objc.registerName("RTFFromRange:"); +final _objc_msgSend_181 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, _NSRange)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, _NSRange)>(); +late final _sel_RTFDFromRange_ = objc.registerName("RTFDFromRange:"); +late final _sel_writeRTFDToFile_atomically_ = + objc.registerName("writeRTFDToFile:atomically:"); +final _objc_msgSend_182 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_readRTFDFromFile_ = objc.registerName("readRTFDFromFile:"); +final _objc_msgSend_183 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isEditable = objc.registerName("isEditable"); +late final _sel_setEditable_ = objc.registerName("setEditable:"); +late final _sel_isSelectable = objc.registerName("isSelectable"); +late final _sel_setSelectable_ = objc.registerName("setSelectable:"); +late final _sel_isRichText = objc.registerName("isRichText"); +late final _sel_setRichText_ = objc.registerName("setRichText:"); +late final _sel_importsGraphics = objc.registerName("importsGraphics"); +late final _sel_setImportsGraphics_ = objc.registerName("setImportsGraphics:"); +late final _sel_isFieldEditor = objc.registerName("isFieldEditor"); +late final _sel_setFieldEditor_ = objc.registerName("setFieldEditor:"); +late final _sel_usesFontPanel = objc.registerName("usesFontPanel"); +late final _sel_setUsesFontPanel_ = objc.registerName("setUsesFontPanel:"); +late final _sel_drawsBackground = objc.registerName("drawsBackground"); +late final _sel_setDrawsBackground_ = objc.registerName("setDrawsBackground:"); + +/// NSColor +class NSColor extends objc.ObjCObjectBase { + NSColor._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSColor] that points to the same underlying object as [other]. + NSColor.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSColor] that wraps the given raw object pointer. + NSColor.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSColor]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSColor); + } +} + +late final _class_NSColor = objc.getClass("NSColor"); +late final _sel_backgroundColor = objc.registerName("backgroundColor"); +final _objc_msgSend_184 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setBackgroundColor_ = objc.registerName("setBackgroundColor:"); +final _objc_msgSend_185 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isRulerVisible = objc.registerName("isRulerVisible"); +late final _sel_selectedRange = objc.registerName("selectedRange"); +final _objc_msgSend_186 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + _NSRange Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + _NSRange Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_186Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer<_NSRange>, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer<_NSRange>, ffi.Pointer, + ffi.Pointer)>(); +late final _sel_setSelectedRange_ = objc.registerName("setSelectedRange:"); +final _objc_msgSend_187 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, _NSRange)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, _NSRange)>(); +late final _sel_scrollRangeToVisible_ = + objc.registerName("scrollRangeToVisible:"); +final _objc_msgSend_188 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, _NSRange)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, _NSRange)>(); +final _objc_msgSend_189 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_190 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_textColor = objc.registerName("textColor"); +late final _sel_setTextColor_ = objc.registerName("setTextColor:"); + +enum NSTextAlignment { + NSTextAlignmentLeft(0), + NSTextAlignmentCenter(1), + NSTextAlignmentRight(2), + NSTextAlignmentJustified(3), + NSTextAlignmentNatural(4); + + final int value; + const NSTextAlignment(this.value); + + static NSTextAlignment fromValue(int value) => switch (value) { + 0 => NSTextAlignmentLeft, + 1 => NSTextAlignmentCenter, + 2 => NSTextAlignmentRight, + 3 => NSTextAlignmentJustified, + 4 => NSTextAlignmentNatural, + _ => throw ArgumentError("Unknown value for NSTextAlignment: $value"), + }; +} + +late final _sel_alignment = objc.registerName("alignment"); +final _objc_msgSend_191 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAlignment_ = objc.registerName("setAlignment:"); +final _objc_msgSend_192 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +enum NSWritingDirection { + NSWritingDirectionNatural(-1), + NSWritingDirectionLeftToRight(0), + NSWritingDirectionRightToLeft(1); + + final int value; + const NSWritingDirection(this.value); + + static NSWritingDirection fromValue(int value) => switch (value) { + -1 => NSWritingDirectionNatural, + 0 => NSWritingDirectionLeftToRight, + 1 => NSWritingDirectionRightToLeft, + _ => + throw ArgumentError("Unknown value for NSWritingDirection: $value"), + }; +} + +late final _sel_baseWritingDirection = + objc.registerName("baseWritingDirection"); +final _objc_msgSend_193 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setBaseWritingDirection_ = + objc.registerName("setBaseWritingDirection:"); +final _objc_msgSend_194 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_setTextColor_range_ = objc.registerName("setTextColor:range:"); +final _objc_msgSend_195 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + _NSRange)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + _NSRange)>(); +late final _sel_setFont_range_ = objc.registerName("setFont:range:"); +final _objc_msgSend_196 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + _NSRange)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + _NSRange)>(); +late final _sel_maxSize = objc.registerName("maxSize"); +late final _sel_setMaxSize_ = objc.registerName("setMaxSize:"); +final _objc_msgSend_197 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGSize)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGSize)>(); +late final _sel_minSize = objc.registerName("minSize"); +late final _sel_setMinSize_ = objc.registerName("setMinSize:"); +late final _sel_isHorizontallyResizable = + objc.registerName("isHorizontallyResizable"); +late final _sel_setHorizontallyResizable_ = + objc.registerName("setHorizontallyResizable:"); +late final _sel_isVerticallyResizable = + objc.registerName("isVerticallyResizable"); +late final _sel_setVerticallyResizable_ = + objc.registerName("setVerticallyResizable:"); +late final _sel_sizeToFit = objc.registerName("sizeToFit"); +late final _sel_copy_ = objc.registerName("copy:"); +late final _sel_copyFont_ = objc.registerName("copyFont:"); +late final _sel_copyRuler_ = objc.registerName("copyRuler:"); +late final _sel_cut_ = objc.registerName("cut:"); +late final _sel_delete_ = objc.registerName("delete:"); +late final _sel_paste_ = objc.registerName("paste:"); +late final _sel_pasteFont_ = objc.registerName("pasteFont:"); +late final _sel_pasteRuler_ = objc.registerName("pasteRuler:"); +late final _sel_selectAll_ = objc.registerName("selectAll:"); +late final _sel_changeFont_ = objc.registerName("changeFont:"); +late final _sel_alignLeft_ = objc.registerName("alignLeft:"); +late final _sel_alignRight_ = objc.registerName("alignRight:"); +late final _sel_alignCenter_ = objc.registerName("alignCenter:"); +late final _sel_subscript_ = objc.registerName("subscript:"); +late final _sel_superscript_ = objc.registerName("superscript:"); +late final _sel_underline_ = objc.registerName("underline:"); +late final _sel_unscript_ = objc.registerName("unscript:"); +late final _sel_showGuessPanel_ = objc.registerName("showGuessPanel:"); +late final _sel_checkSpelling_ = objc.registerName("checkSpelling:"); +late final _sel_toggleRuler_ = objc.registerName("toggleRuler:"); +late final _sel_fieldEditor_forObject_ = + objc.registerName("fieldEditor:forObject:"); +final _objc_msgSend_198 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + bool, + ffi.Pointer)>(); +late final _sel_endEditingFor_ = objc.registerName("endEditingFor:"); +late final _sel_constrainFrameRect_toScreen_ = + objc.registerName("constrainFrameRect:toScreen:"); +final _objc_msgSend_199 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + CGRect Function( + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +final _objc_msgSend_199Stret = objc.msgSendStretPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGRect, + ffi.Pointer)>(); +late final _sel_setFrame_display_ = objc.registerName("setFrame:display:"); +final _objc_msgSend_200 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGRect, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGRect, bool)>(); +late final _sel_setContentSize_ = objc.registerName("setContentSize:"); +late final _sel_setFrameTopLeftPoint_ = + objc.registerName("setFrameTopLeftPoint:"); +late final _sel_cascadeTopLeftFromPoint_ = + objc.registerName("cascadeTopLeftFromPoint:"); +late final _sel_animationResizeTime_ = + objc.registerName("animationResizeTime:"); +final _objc_msgSend_201 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Double Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +final _objc_msgSend_201Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Double Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_setFrame_display_animate_ = + objc.registerName("setFrame:display:animate:"); +final _objc_msgSend_202 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, CGRect, ffi.Bool, ffi.Bool)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, CGRect, bool, bool)>(); +late final _sel_resizeIncrements = objc.registerName("resizeIncrements"); +late final _sel_setResizeIncrements_ = + objc.registerName("setResizeIncrements:"); +late final _sel_aspectRatio = objc.registerName("aspectRatio"); +late final _sel_setAspectRatio_ = objc.registerName("setAspectRatio:"); +late final _sel_contentResizeIncrements = + objc.registerName("contentResizeIncrements"); +late final _sel_setContentResizeIncrements_ = + objc.registerName("setContentResizeIncrements:"); +late final _sel_contentAspectRatio = objc.registerName("contentAspectRatio"); +late final _sel_setContentAspectRatio_ = + objc.registerName("setContentAspectRatio:"); +late final _sel_viewsNeedDisplay = objc.registerName("viewsNeedDisplay"); +late final _sel_setViewsNeedDisplay_ = + objc.registerName("setViewsNeedDisplay:"); +late final _sel_setPreservesContentDuringLiveResize_ = + objc.registerName("setPreservesContentDuringLiveResize:"); +late final _sel_makeFirstResponder_ = objc.registerName("makeFirstResponder:"); +final _objc_msgSend_203 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_firstResponder = objc.registerName("firstResponder"); +late final _sel_resizeFlags = objc.registerName("resizeFlags"); +late final _sel_close = objc.registerName("close"); +late final _sel_isReleasedWhenClosed = + objc.registerName("isReleasedWhenClosed"); +late final _sel_setReleasedWhenClosed_ = + objc.registerName("setReleasedWhenClosed:"); +late final _sel_miniaturize_ = objc.registerName("miniaturize:"); +late final _sel_deminiaturize_ = objc.registerName("deminiaturize:"); +late final _sel_isZoomed = objc.registerName("isZoomed"); +late final _sel_zoom_ = objc.registerName("zoom:"); +late final _sel_isMiniaturized = objc.registerName("isMiniaturized"); +final _objc_msgSend_204 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +final _objc_msgSend_205 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +enum NSRectEdge { + NSRectEdgeMinX(0), + NSRectEdgeMinY(1), + NSRectEdgeMaxX(2), + NSRectEdgeMaxY(3); + + static const NSMinXEdge = NSRectEdgeMinX; + static const NSMinYEdge = NSRectEdgeMinY; + static const NSMaxXEdge = NSRectEdgeMaxX; + static const NSMaxYEdge = NSRectEdgeMaxY; + + final int value; + const NSRectEdge(this.value); + + static NSRectEdge fromValue(int value) => switch (value) { + 0 => NSRectEdgeMinX, + 1 => NSRectEdgeMinY, + 2 => NSRectEdgeMaxX, + 3 => NSRectEdgeMaxY, + _ => throw ArgumentError("Unknown value for NSRectEdge: $value"), + }; + + @override + String toString() { + if (this == NSRectEdgeMinX) + return "NSRectEdge.NSRectEdgeMinX, NSRectEdge.NSMinXEdge"; + if (this == NSRectEdgeMinY) + return "NSRectEdge.NSRectEdgeMinY, NSRectEdge.NSMinYEdge"; + if (this == NSRectEdgeMaxX) + return "NSRectEdge.NSRectEdgeMaxX, NSRectEdge.NSMaxXEdge"; + if (this == NSRectEdgeMaxY) + return "NSRectEdge.NSRectEdgeMaxY, NSRectEdge.NSMaxYEdge"; + return super.toString(); + } +} + +late final _sel_setContentBorderThickness_forEdge_ = + objc.registerName("setContentBorderThickness:forEdge:"); +final _objc_msgSend_206 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, double, int)>(); +late final _sel_contentBorderThicknessForEdge_ = + objc.registerName("contentBorderThicknessForEdge:"); +final _objc_msgSend_207 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Double Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, int)>(); +final _objc_msgSend_207Fpret = objc.msgSendFpretPointer + .cast< + ffi.NativeFunction< + ffi.Double Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + double Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_setAutorecalculatesContentBorderThickness_forEdge_ = + objc.registerName("setAutorecalculatesContentBorderThickness:forEdge:"); +final _objc_msgSend_208 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Bool, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, bool, int)>(); +late final _sel_autorecalculatesContentBorderThicknessForEdge_ = + objc.registerName("autorecalculatesContentBorderThicknessForEdge:"); +final _objc_msgSend_209 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_isMovable = objc.registerName("isMovable"); +late final _sel_setMovable_ = objc.registerName("setMovable:"); +late final _sel_isMovableByWindowBackground = + objc.registerName("isMovableByWindowBackground"); +late final _sel_setMovableByWindowBackground_ = + objc.registerName("setMovableByWindowBackground:"); +late final _sel_hidesOnDeactivate = objc.registerName("hidesOnDeactivate"); +late final _sel_setHidesOnDeactivate_ = + objc.registerName("setHidesOnDeactivate:"); +late final _sel_canHide = objc.registerName("canHide"); +late final _sel_setCanHide_ = objc.registerName("setCanHide:"); +late final _sel_center = objc.registerName("center"); +late final _sel_makeKeyAndOrderFront_ = + objc.registerName("makeKeyAndOrderFront:"); +late final _sel_orderFront_ = objc.registerName("orderFront:"); +late final _sel_orderBack_ = objc.registerName("orderBack:"); +late final _sel_orderOut_ = objc.registerName("orderOut:"); +late final _sel_orderWindow_relativeTo_ = + objc.registerName("orderWindow:relativeTo:"); +final _objc_msgSend_210 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Long, ffi.Long)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int, int)>(); +late final _sel_orderFrontRegardless = + objc.registerName("orderFrontRegardless"); +late final _sel_miniwindowImage = objc.registerName("miniwindowImage"); +late final _sel_setMiniwindowImage_ = objc.registerName("setMiniwindowImage:"); +late final _sel_miniwindowTitle = objc.registerName("miniwindowTitle"); +late final _sel_setMiniwindowTitle_ = objc.registerName("setMiniwindowTitle:"); + +/// NSDockTile +class NSDockTile extends objc.ObjCObjectBase { + NSDockTile._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSDockTile] that points to the same underlying object as [other]. + NSDockTile.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSDockTile] that wraps the given raw object pointer. + NSDockTile.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSDockTile]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSDockTile); + } +} + +late final _class_NSDockTile = objc.getClass("NSDockTile"); +late final _sel_dockTile = objc.registerName("dockTile"); +final _objc_msgSend_211 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isDocumentEdited = objc.registerName("isDocumentEdited"); +late final _sel_setDocumentEdited_ = objc.registerName("setDocumentEdited:"); +late final _sel_isVisible = objc.registerName("isVisible"); +late final _sel_isKeyWindow = objc.registerName("isKeyWindow"); +late final _sel_isMainWindow = objc.registerName("isMainWindow"); +late final _sel_canBecomeKeyWindow = objc.registerName("canBecomeKeyWindow"); +late final _sel_canBecomeMainWindow = objc.registerName("canBecomeMainWindow"); +late final _sel_makeKeyWindow = objc.registerName("makeKeyWindow"); +late final _sel_makeMainWindow = objc.registerName("makeMainWindow"); +late final _sel_becomeKeyWindow = objc.registerName("becomeKeyWindow"); +late final _sel_resignKeyWindow = objc.registerName("resignKeyWindow"); +late final _sel_becomeMainWindow = objc.registerName("becomeMainWindow"); +late final _sel_resignMainWindow = objc.registerName("resignMainWindow"); +late final _sel_worksWhenModal = objc.registerName("worksWhenModal"); +late final _sel_preventsApplicationTerminationWhenModal = + objc.registerName("preventsApplicationTerminationWhenModal"); +late final _sel_setPreventsApplicationTerminationWhenModal_ = + objc.registerName("setPreventsApplicationTerminationWhenModal:"); +late final _sel_convertRectToScreen_ = + objc.registerName("convertRectToScreen:"); +late final _sel_convertRectFromScreen_ = + objc.registerName("convertRectFromScreen:"); +late final _sel_convertPointToScreen_ = + objc.registerName("convertPointToScreen:"); +late final _sel_convertPointFromScreen_ = + objc.registerName("convertPointFromScreen:"); +late final _sel_backingScaleFactor = objc.registerName("backingScaleFactor"); +late final _sel_performClose_ = objc.registerName("performClose:"); +late final _sel_performMiniaturize_ = objc.registerName("performMiniaturize:"); +late final _sel_performZoom_ = objc.registerName("performZoom:"); +late final _sel_dataWithEPSInsideRect_ = + objc.registerName("dataWithEPSInsideRect:"); +final _objc_msgSend_212 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGRect)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, CGRect)>(); +late final _sel_dataWithPDFInsideRect_ = + objc.registerName("dataWithPDFInsideRect:"); +late final _sel_print_ = objc.registerName("print:"); +late final _sel_allowsToolTipsWhenApplicationIsInactive = + objc.registerName("allowsToolTipsWhenApplicationIsInactive"); +late final _sel_setAllowsToolTipsWhenApplicationIsInactive_ = + objc.registerName("setAllowsToolTipsWhenApplicationIsInactive:"); +late final _sel_backingType = objc.registerName("backingType"); +final _objc_msgSend_213 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setBackingType_ = objc.registerName("setBackingType:"); +final _objc_msgSend_214 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_level = objc.registerName("level"); +late final _sel_setLevel_ = objc.registerName("setLevel:"); +late final _sel_depthLimit = objc.registerName("depthLimit"); +late final _sel_setDepthLimit_ = objc.registerName("setDepthLimit:"); +final _objc_msgSend_215 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Int32)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_setDynamicDepthLimit_ = + objc.registerName("setDynamicDepthLimit:"); +late final _sel_hasDynamicDepthLimit = + objc.registerName("hasDynamicDepthLimit"); +late final _sel_screen = objc.registerName("screen"); +final _objc_msgSend_216 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_deepestScreen = objc.registerName("deepestScreen"); +late final _sel_hasShadow = objc.registerName("hasShadow"); +late final _sel_setHasShadow_ = objc.registerName("setHasShadow:"); +late final _sel_invalidateShadow = objc.registerName("invalidateShadow"); +late final _sel_setOpaque_ = objc.registerName("setOpaque:"); + +/// ! +/// @typedef NSWindowSharingType +/// +/// @const NSWindowSharingNone Window contents may not be read by another process. +/// @const NSWindowSharingReadOnly Window contents may be read but not modified by another process. +/// @const NSWindowSharingReadWrite Window contents may be read or modified by another process. +enum NSWindowSharingType { + NSWindowSharingNone(0), + NSWindowSharingReadOnly(1), + NSWindowSharingReadWrite(2); + + final int value; + const NSWindowSharingType(this.value); + + static NSWindowSharingType fromValue(int value) => switch (value) { + 0 => NSWindowSharingNone, + 1 => NSWindowSharingReadOnly, + 2 => NSWindowSharingReadWrite, + _ => + throw ArgumentError("Unknown value for NSWindowSharingType: $value"), + }; +} + +late final _sel_sharingType = objc.registerName("sharingType"); +final _objc_msgSend_217 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setSharingType_ = objc.registerName("setSharingType:"); +final _objc_msgSend_218 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_allowsConcurrentViewDrawing = + objc.registerName("allowsConcurrentViewDrawing"); +late final _sel_setAllowsConcurrentViewDrawing_ = + objc.registerName("setAllowsConcurrentViewDrawing:"); +late final _sel_displaysWhenScreenProfileChanges = + objc.registerName("displaysWhenScreenProfileChanges"); +late final _sel_setDisplaysWhenScreenProfileChanges_ = + objc.registerName("setDisplaysWhenScreenProfileChanges:"); +late final _sel_disableScreenUpdatesUntilFlush = + objc.registerName("disableScreenUpdatesUntilFlush"); +late final _sel_canBecomeVisibleWithoutLogin = + objc.registerName("canBecomeVisibleWithoutLogin"); +late final _sel_setCanBecomeVisibleWithoutLogin_ = + objc.registerName("setCanBecomeVisibleWithoutLogin:"); + +/// ! +/// @typedef NSWindowCollectionBehavior +/// +/// @const NSWindowCollectionBehaviorPrimary Marks a window as primary. This collection behavior should commonly be used for document or viewer windows. +/// @const NSWindowCollectionBehaviorAuxiliary Marks a window as auxiliary. This collection behavior should commonly be used for About or Settings windows, as well as utility panes. +/// @const NSWindowCollectionBehaviorCanJoinAllApplications Marks a window as able to join all applications, allowing it to join other apps' sets and full screen spaces when eligible. This collection behavior should commonly be used for floating windows and system overlays. +/// +/// @discussion You may specify at most one of @c NSWindowCollectionBehaviorPrimary, @c NSWindowCollectionBehaviorAuxiliary, or @c NSWindowCollectionBehaviorCanJoinAllApplications. If unspecified, the window gets the default treatment determined by its other collection behaviors. +/// +/// @const NSWindowCollectionBehaviorDefault +/// @const NSWindowCollectionBehaviorCanJoinAllSpaces +/// @const NSWindowCollectionBehaviorMoveToActiveSpace +/// +/// @discussion You may specify at most one of \c NSWindowCollectionBehaviorManaged, \c NSWindowCollectionBehaviorTransient, or \c NSWindowCollectionBehaviorStationary. If neither is specified, the window gets the default behavior determined by its window level. +/// +/// @const NSWindowCollectionBehaviorManaged Participates in spaces, exposé. Default behavior if `windowLevel == NSNormalWindowLevel`. +/// @const NSWindowCollectionBehaviorTransient Floats in spaces, hidden by exposé. Default behavior if `windowLevel != NSNormalWindowLevel`. +/// @const NSWindowCollectionBehaviorStationary Unaffected by exposé. Stays visible and stationary, like desktop window. +/// +/// @discussion You may specify at most one of \c NSWindowCollectionBehaviorParticipatesInCycle or \c NSWindowCollectionBehaviorIgnoresCycle. If unspecified, the window gets the default behavior determined by its window level. +/// +/// @const NSWindowCollectionBehaviorParticipatesInCycle Default behavior if `windowLevel != NSNormalWindowLevel`. +/// @const NSWindowCollectionBehaviorIgnoresCycle Default behavior if `windowLevel != NSNormalWindowLevel`. +/// +/// @discussion You may specify at most one of \c NSWindowCollectionBehaviorFullScreenPrimary, \c NSWindowCollectionBehaviorFullScreenAuxiliary, or \c NSWindowCollectionBehaviorFullScreenNone. +/// +/// @const NSWindowCollectionBehaviorFullScreenPrimary The frontmost window with this collection behavior will be the fullscreen window. +/// @const NSWindowCollectionBehaviorFullScreenAuxiliary Windows with this collection behavior can be shown with the fullscreen window. +/// @const NSWindowCollectionBehaviorFullScreenNone The window can not be made fullscreen when this bit is set. +/// +/// @discussion You may specify at most one of \c NSWindowCollectionBehaviorFullScreenAllowsTiling or \c NSWindowCollectionBehaviorFullScreenDisallowsTiling, or an assertion will be raised. +/// +/// The default behavior is to allow any window to participate in full screen tiling, as long as it meets certain requirements, such as being resizable and not a panel or sheet. Windows which are not full screen capable can still become a secondary tile in full screen. A window can explicitly allow itself to be placed into a full screen tile by including \c NSWindowCollectionBehaviorFullScreenAllowsTiling. Even if a window allows itself to be placed in a tile, it still may not be put in the tile if its \c minFullScreenContentSize is too large to fit. A window can explicitly disallow itself from being placed in a full screen tile by including \c NSWindowCollectionBehaviorFullScreenDisallowsTiling. This is useful for non-full screen capable windows to explicitly prevent themselves from being tiled. It can also be used by a full screen window to prevent any other windows from being placed in its full screen tile. +/// +/// @const NSWindowCollectionBehaviorFullScreenAllowsTiling This window can be a full screen tile window. It does not have to have \c NSWindowCollectionBehaviorFullScreenPrimary set. +/// @const NSWindowCollectionBehaviorFullScreenDisallowsTiling This window can NOT be made a full screen tile window; it still may be allowed to be a regular \c NSWindowCollectionBehaviorFullScreenPrimary window. +enum NSWindowCollectionBehavior { + NSWindowCollectionBehaviorDefault(0), + NSWindowCollectionBehaviorCanJoinAllSpaces(1), + NSWindowCollectionBehaviorMoveToActiveSpace(2), + NSWindowCollectionBehaviorManaged(4), + NSWindowCollectionBehaviorTransient(8), + NSWindowCollectionBehaviorStationary(16), + NSWindowCollectionBehaviorParticipatesInCycle(32), + NSWindowCollectionBehaviorIgnoresCycle(64), + NSWindowCollectionBehaviorFullScreenPrimary(128), + NSWindowCollectionBehaviorFullScreenAuxiliary(256), + NSWindowCollectionBehaviorFullScreenNone(512), + NSWindowCollectionBehaviorFullScreenAllowsTiling(2048), + NSWindowCollectionBehaviorFullScreenDisallowsTiling(4096), + NSWindowCollectionBehaviorPrimary(65536), + NSWindowCollectionBehaviorAuxiliary(131072), + NSWindowCollectionBehaviorCanJoinAllApplications(262144); + + final int value; + const NSWindowCollectionBehavior(this.value); + + static NSWindowCollectionBehavior fromValue(int value) => switch (value) { + 0 => NSWindowCollectionBehaviorDefault, + 1 => NSWindowCollectionBehaviorCanJoinAllSpaces, + 2 => NSWindowCollectionBehaviorMoveToActiveSpace, + 4 => NSWindowCollectionBehaviorManaged, + 8 => NSWindowCollectionBehaviorTransient, + 16 => NSWindowCollectionBehaviorStationary, + 32 => NSWindowCollectionBehaviorParticipatesInCycle, + 64 => NSWindowCollectionBehaviorIgnoresCycle, + 128 => NSWindowCollectionBehaviorFullScreenPrimary, + 256 => NSWindowCollectionBehaviorFullScreenAuxiliary, + 512 => NSWindowCollectionBehaviorFullScreenNone, + 2048 => NSWindowCollectionBehaviorFullScreenAllowsTiling, + 4096 => NSWindowCollectionBehaviorFullScreenDisallowsTiling, + 65536 => NSWindowCollectionBehaviorPrimary, + 131072 => NSWindowCollectionBehaviorAuxiliary, + 262144 => NSWindowCollectionBehaviorCanJoinAllApplications, + _ => throw ArgumentError( + "Unknown value for NSWindowCollectionBehavior: $value"), + }; +} + +late final _sel_collectionBehavior = objc.registerName("collectionBehavior"); +final _objc_msgSend_219 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setCollectionBehavior_ = + objc.registerName("setCollectionBehavior:"); +final _objc_msgSend_220 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +/// ! +/// @typedef NSWindowAnimationBehavior +/// +/// @const NSWindowAnimationBehaviorDefault Let AppKit infer animation behavior for this window. +/// @const NSWindowAnimationBehaviorNone Suppress inferred animations (don't animate). +/// @const NSWindowAnimationBehaviorDocumentWindow +/// @const NSWindowAnimationBehaviorUtilityWindow +/// @const NSWindowAnimationBehaviorAlertPanel +enum NSWindowAnimationBehavior { + NSWindowAnimationBehaviorDefault(0), + NSWindowAnimationBehaviorNone(2), + NSWindowAnimationBehaviorDocumentWindow(3), + NSWindowAnimationBehaviorUtilityWindow(4), + NSWindowAnimationBehaviorAlertPanel(5); + + final int value; + const NSWindowAnimationBehavior(this.value); + + static NSWindowAnimationBehavior fromValue(int value) => switch (value) { + 0 => NSWindowAnimationBehaviorDefault, + 2 => NSWindowAnimationBehaviorNone, + 3 => NSWindowAnimationBehaviorDocumentWindow, + 4 => NSWindowAnimationBehaviorUtilityWindow, + 5 => NSWindowAnimationBehaviorAlertPanel, + _ => throw ArgumentError( + "Unknown value for NSWindowAnimationBehavior: $value"), + }; +} + +late final _sel_animationBehavior = objc.registerName("animationBehavior"); +final _objc_msgSend_221 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAnimationBehavior_ = + objc.registerName("setAnimationBehavior:"); +final _objc_msgSend_222 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_isOnActiveSpace = objc.registerName("isOnActiveSpace"); +late final _sel_toggleFullScreen_ = objc.registerName("toggleFullScreen:"); +late final _sel_stringWithSavedFrame = + objc.registerName("stringWithSavedFrame"); +late final _sel_setFrameFromString_ = objc.registerName("setFrameFromString:"); +late final _sel_saveFrameUsingName_ = objc.registerName("saveFrameUsingName:"); +late final _sel_setFrameUsingName_force_ = + objc.registerName("setFrameUsingName:force:"); +late final _sel_setFrameUsingName_ = objc.registerName("setFrameUsingName:"); +late final _sel_setFrameAutosaveName_ = + objc.registerName("setFrameAutosaveName:"); +late final _sel_frameAutosaveName = objc.registerName("frameAutosaveName"); +late final _sel_removeFrameUsingName_ = + objc.registerName("removeFrameUsingName:"); +late final _sel_contentMinSize = objc.registerName("contentMinSize"); +late final _sel_setContentMinSize_ = objc.registerName("setContentMinSize:"); +late final _sel_contentMaxSize = objc.registerName("contentMaxSize"); +late final _sel_setContentMaxSize_ = objc.registerName("setContentMaxSize:"); +late final _sel_minFullScreenContentSize = + objc.registerName("minFullScreenContentSize"); +late final _sel_setMinFullScreenContentSize_ = + objc.registerName("setMinFullScreenContentSize:"); +late final _sel_maxFullScreenContentSize = + objc.registerName("maxFullScreenContentSize"); +late final _sel_setMaxFullScreenContentSize_ = + objc.registerName("setMaxFullScreenContentSize:"); +late final _sel_deviceDescription = objc.registerName("deviceDescription"); +final _objc_msgSend_223 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSWindowController +class NSWindowController extends objc.ObjCObjectBase { + NSWindowController._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSWindowController] that points to the same underlying object as [other]. + NSWindowController.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSWindowController] that wraps the given raw object pointer. + NSWindowController.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSWindowController]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSWindowController); + } +} + +late final _class_NSWindowController = objc.getClass("NSWindowController"); +late final _sel_windowController = objc.registerName("windowController"); +final _objc_msgSend_224 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setWindowController_ = + objc.registerName("setWindowController:"); +final _objc_msgSend_225 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +void _ObjCBlock_ffiVoid_ffiLong_fnPtrTrampoline( + ffi.Pointer block, int arg0) => + block.ref.target + .cast>() + .asFunction()(arg0); +void _ObjCBlock_ffiVoid_ffiLong_closureTrampoline( + ffi.Pointer block, int arg0) => + (objc.getBlockClosure(block) as void Function(int))(arg0); + +class ObjCBlock_ffiVoid_ffiLong extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiLong._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiLong castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiLong._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiLong.fromFunctionPointer( + ffi.Pointer> ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Long)>(_ObjCBlock_ffiVoid_ffiLong_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiLong.fromFunction(void Function(int) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Long)>(_ObjCBlock_ffiVoid_ffiLong_closureTrampoline) + .cast(), + (int arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiLong.listener(void Function(int) fn) + : this._((objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Long)>.listener( + _ObjCBlock_ffiVoid_ffiLong_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (int arg0) => fn(arg0)))); + static ffi + .NativeCallable, ffi.Long)>? + _dartFuncListenerTrampoline; + + void call(int arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, ffi.Long arg0)>>() + .asFunction, int)>()( + pointer, arg0); +} + +late final _sel_beginSheet_completionHandler_ = + objc.registerName("beginSheet:completionHandler:"); +final _objc_msgSend_226 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_beginCriticalSheet_completionHandler_ = + objc.registerName("beginCriticalSheet:completionHandler:"); +late final _sel_endSheet_ = objc.registerName("endSheet:"); +final _objc_msgSend_227 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_endSheet_returnCode_ = + objc.registerName("endSheet:returnCode:"); +final _objc_msgSend_228 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Long)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_sheets = objc.registerName("sheets"); +late final _sel_attachedSheet = objc.registerName("attachedSheet"); +late final _sel_isSheet = objc.registerName("isSheet"); +late final _sel_sheetParent = objc.registerName("sheetParent"); + +/// NSButton +class NSButton extends objc.ObjCObjectBase { + NSButton._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSButton] that points to the same underlying object as [other]. + NSButton.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSButton] that wraps the given raw object pointer. + NSButton.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSButton]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSButton); + } +} + +late final _class_NSButton = objc.getClass("NSButton"); + +/// ! +/// @typedef NSWindowButton +/// +/// Standard window buttons. +enum NSWindowButton { + NSWindowCloseButton(0), + NSWindowMiniaturizeButton(1), + NSWindowZoomButton(2), + NSWindowToolbarButton(3), + NSWindowDocumentIconButton(4), + NSWindowDocumentVersionsButton(6); + + final int value; + const NSWindowButton(this.value); + + static NSWindowButton fromValue(int value) => switch (value) { + 0 => NSWindowCloseButton, + 1 => NSWindowMiniaturizeButton, + 2 => NSWindowZoomButton, + 3 => NSWindowToolbarButton, + 4 => NSWindowDocumentIconButton, + 6 => NSWindowDocumentVersionsButton, + _ => throw ArgumentError("Unknown value for NSWindowButton: $value"), + }; +} + +late final _sel_standardWindowButton_forStyleMask_ = + objc.registerName("standardWindowButton:forStyleMask:"); +final _objc_msgSend_229 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int, int)>(); +late final _sel_standardWindowButton_ = + objc.registerName("standardWindowButton:"); +final _objc_msgSend_230 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_addChildWindow_ordered_ = + objc.registerName("addChildWindow:ordered:"); +final _objc_msgSend_231 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Long)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_removeChildWindow_ = objc.registerName("removeChildWindow:"); +late final _sel_childWindows = objc.registerName("childWindows"); +final _objc_msgSend_232 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_parentWindow = objc.registerName("parentWindow"); +late final _sel_setParentWindow_ = objc.registerName("setParentWindow:"); +final _objc_msgSend_233 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_appearanceSource = objc.registerName("appearanceSource"); +final _objc_msgSend_234 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAppearanceSource_ = + objc.registerName("setAppearanceSource:"); +final _objc_msgSend_235 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// NSColorSpace +class NSColorSpace extends objc.ObjCObjectBase { + NSColorSpace._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSColorSpace] that points to the same underlying object as [other]. + NSColorSpace.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSColorSpace] that wraps the given raw object pointer. + NSColorSpace.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSColorSpace]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSColorSpace); + } +} + +late final _class_NSColorSpace = objc.getClass("NSColorSpace"); +late final _sel_colorSpace = objc.registerName("colorSpace"); +final _objc_msgSend_236 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setColorSpace_ = objc.registerName("setColorSpace:"); +final _objc_msgSend_237 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +enum NSDisplayGamut { + NSDisplayGamutSRGB(1), + NSDisplayGamutP3(2); + + final int value; + const NSDisplayGamut(this.value); + + static NSDisplayGamut fromValue(int value) => switch (value) { + 1 => NSDisplayGamutSRGB, + 2 => NSDisplayGamutP3, + _ => throw ArgumentError("Unknown value for NSDisplayGamut: $value"), + }; +} + +late final _sel_canRepresentDisplayGamut_ = + objc.registerName("canRepresentDisplayGamut:"); +final _objc_msgSend_238 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, int)>(); + +/// ! +/// @typedef NSWindowNumberListOptions +/// +/// Options used in `+windowNumbersWithOptions:`. If no options are specified, the returned list contains window numbers for visible windows on the active space belonging to the calling application. +/// +/// @const NSWindowNumberListAllApplications +/// @const NSWindowNumberListAllSpaces +enum NSWindowNumberListOptions { + NSWindowNumberListAllApplications(1), + NSWindowNumberListAllSpaces(16); + + final int value; + const NSWindowNumberListOptions(this.value); + + static NSWindowNumberListOptions fromValue(int value) => switch (value) { + 1 => NSWindowNumberListAllApplications, + 16 => NSWindowNumberListAllSpaces, + _ => throw ArgumentError( + "Unknown value for NSWindowNumberListOptions: $value"), + }; +} + +late final _sel_windowNumbersWithOptions_ = + objc.registerName("windowNumbersWithOptions:"); +final _objc_msgSend_239 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_windowNumberAtPoint_belowWindowWithWindowNumber_ = + objc.registerName("windowNumberAtPoint:belowWindowWithWindowNumber:"); +final _objc_msgSend_240 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer, CGPoint, ffi.Long)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, CGPoint, int)>(); + +/// ! +/// @typedef NSWindowOcclusionState +/// +/// @const NSWindowOcclusionStateVisible If set, at least part of the window is visible. If not set, the entire window is occluded. Windows with non-rectangular shapes may be completely occluded on screen but still count as visible, if their bounding box falls into a visible region. Windows that are completely transparent may also still count as visible. +enum NSWindowOcclusionState { + NSWindowOcclusionStateVisible(2); + + final int value; + const NSWindowOcclusionState(this.value); + + static NSWindowOcclusionState fromValue(int value) => switch (value) { + 2 => NSWindowOcclusionStateVisible, + _ => throw ArgumentError( + "Unknown value for NSWindowOcclusionState: $value"), + }; +} + +late final _sel_occlusionState = objc.registerName("occlusionState"); +final _objc_msgSend_241 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +enum NSTitlebarSeparatorStyle { + NSTitlebarSeparatorStyleAutomatic(0), + NSTitlebarSeparatorStyleNone(1), + NSTitlebarSeparatorStyleLine(2), + NSTitlebarSeparatorStyleShadow(3); + + final int value; + const NSTitlebarSeparatorStyle(this.value); + + static NSTitlebarSeparatorStyle fromValue(int value) => switch (value) { + 0 => NSTitlebarSeparatorStyleAutomatic, + 1 => NSTitlebarSeparatorStyleNone, + 2 => NSTitlebarSeparatorStyleLine, + 3 => NSTitlebarSeparatorStyleShadow, + _ => throw ArgumentError( + "Unknown value for NSTitlebarSeparatorStyle: $value"), + }; +} + +late final _sel_titlebarSeparatorStyle = + objc.registerName("titlebarSeparatorStyle"); +final _objc_msgSend_242 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setTitlebarSeparatorStyle_ = + objc.registerName("setTitlebarSeparatorStyle:"); +final _objc_msgSend_243 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); + +/// NSViewController +class NSViewController extends objc.ObjCObjectBase { + NSViewController._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSViewController] that points to the same underlying object as [other]. + NSViewController.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSViewController] that wraps the given raw object pointer. + NSViewController.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSViewController]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSViewController); + } +} + +late final _class_NSViewController = objc.getClass("NSViewController"); +late final _sel_contentViewController = + objc.registerName("contentViewController"); +final _objc_msgSend_244 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setContentViewController_ = + objc.registerName("setContentViewController:"); +final _objc_msgSend_245 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_windowWithContentViewController_ = + objc.registerName("windowWithContentViewController:"); +final _objc_msgSend_246 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_performWindowDragWithEvent_ = + objc.registerName("performWindowDragWithEvent:"); +late final _sel_initialFirstResponder = + objc.registerName("initialFirstResponder"); +late final _sel_setInitialFirstResponder_ = + objc.registerName("setInitialFirstResponder:"); +late final _sel_selectNextKeyView_ = objc.registerName("selectNextKeyView:"); +late final _sel_selectPreviousKeyView_ = + objc.registerName("selectPreviousKeyView:"); +late final _sel_selectKeyViewFollowingView_ = + objc.registerName("selectKeyViewFollowingView:"); +late final _sel_selectKeyViewPrecedingView_ = + objc.registerName("selectKeyViewPrecedingView:"); + +enum NSSelectionDirection { + NSDirectSelection(0), + NSSelectingNext(1), + NSSelectingPrevious(2); + + final int value; + const NSSelectionDirection(this.value); + + static NSSelectionDirection fromValue(int value) => switch (value) { + 0 => NSDirectSelection, + 1 => NSSelectingNext, + 2 => NSSelectingPrevious, + _ => + throw ArgumentError("Unknown value for NSSelectionDirection: $value"), + }; +} + +late final _sel_keyViewSelectionDirection = + objc.registerName("keyViewSelectionDirection"); +final _objc_msgSend_247 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSButtonCell +class NSButtonCell extends objc.ObjCObjectBase { + NSButtonCell._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSButtonCell] that points to the same underlying object as [other]. + NSButtonCell.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSButtonCell] that wraps the given raw object pointer. + NSButtonCell.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSButtonCell]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSButtonCell); + } +} + +late final _class_NSButtonCell = objc.getClass("NSButtonCell"); +late final _sel_defaultButtonCell = objc.registerName("defaultButtonCell"); +final _objc_msgSend_248 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setDefaultButtonCell_ = + objc.registerName("setDefaultButtonCell:"); +final _objc_msgSend_249 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_disableKeyEquivalentForDefaultButtonCell = + objc.registerName("disableKeyEquivalentForDefaultButtonCell"); +late final _sel_enableKeyEquivalentForDefaultButtonCell = + objc.registerName("enableKeyEquivalentForDefaultButtonCell"); +late final _sel_autorecalculatesKeyViewLoop = + objc.registerName("autorecalculatesKeyViewLoop"); +late final _sel_setAutorecalculatesKeyViewLoop_ = + objc.registerName("setAutorecalculatesKeyViewLoop:"); +late final _sel_recalculateKeyViewLoop = + objc.registerName("recalculateKeyViewLoop"); + +/// NSToolbar +class NSToolbar extends objc.ObjCObjectBase { + NSToolbar._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSToolbar] that points to the same underlying object as [other]. + NSToolbar.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSToolbar] that wraps the given raw object pointer. + NSToolbar.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSToolbar]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSToolbar); + } +} + +late final _class_NSToolbar = objc.getClass("NSToolbar"); +late final _sel_toolbar = objc.registerName("toolbar"); +final _objc_msgSend_250 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setToolbar_ = objc.registerName("setToolbar:"); +final _objc_msgSend_251 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_toggleToolbarShown_ = objc.registerName("toggleToolbarShown:"); +late final _sel_runToolbarCustomizationPalette_ = + objc.registerName("runToolbarCustomizationPalette:"); +late final _sel_showsToolbarButton = objc.registerName("showsToolbarButton"); +late final _sel_setShowsToolbarButton_ = + objc.registerName("setShowsToolbarButton:"); +late final _sel_allowsAutomaticWindowTabbing = + objc.registerName("allowsAutomaticWindowTabbing"); +late final _sel_setAllowsAutomaticWindowTabbing_ = + objc.registerName("setAllowsAutomaticWindowTabbing:"); + +enum NSWindowUserTabbingPreference { + NSWindowUserTabbingPreferenceManual(0), + NSWindowUserTabbingPreferenceAlways(1), + NSWindowUserTabbingPreferenceInFullScreen(2); + + final int value; + const NSWindowUserTabbingPreference(this.value); + + static NSWindowUserTabbingPreference fromValue(int value) => switch (value) { + 0 => NSWindowUserTabbingPreferenceManual, + 1 => NSWindowUserTabbingPreferenceAlways, + 2 => NSWindowUserTabbingPreferenceInFullScreen, + _ => throw ArgumentError( + "Unknown value for NSWindowUserTabbingPreference: $value"), + }; +} + +late final _sel_userTabbingPreference = + objc.registerName("userTabbingPreference"); +final _objc_msgSend_252 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); + +/// ! +/// @typedef NSWindowTabbingMode +/// +/// @const NSWindowTabbingModeAutomatic The system automatically prefers to tab this window when appropriate. +/// @const NSWindowTabbingModePreferred The window explicitly should prefer to tab when shown. +/// @const NSWindowTabbingModeDisallowed The window explicitly should not prefer to tab when shown. +enum NSWindowTabbingMode { + NSWindowTabbingModeAutomatic(0), + NSWindowTabbingModePreferred(1), + NSWindowTabbingModeDisallowed(2); + + final int value; + const NSWindowTabbingMode(this.value); + + static NSWindowTabbingMode fromValue(int value) => switch (value) { + 0 => NSWindowTabbingModeAutomatic, + 1 => NSWindowTabbingModePreferred, + 2 => NSWindowTabbingModeDisallowed, + _ => + throw ArgumentError("Unknown value for NSWindowTabbingMode: $value"), + }; +} + +late final _sel_tabbingMode = objc.registerName("tabbingMode"); +final _objc_msgSend_253 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setTabbingMode_ = objc.registerName("setTabbingMode:"); +final _objc_msgSend_254 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_tabbingIdentifier = objc.registerName("tabbingIdentifier"); +late final _sel_setTabbingIdentifier_ = + objc.registerName("setTabbingIdentifier:"); +late final _sel_selectNextTab_ = objc.registerName("selectNextTab:"); +late final _sel_selectPreviousTab_ = objc.registerName("selectPreviousTab:"); +late final _sel_moveTabToNewWindow_ = objc.registerName("moveTabToNewWindow:"); +late final _sel_mergeAllWindows_ = objc.registerName("mergeAllWindows:"); +late final _sel_toggleTabBar_ = objc.registerName("toggleTabBar:"); +late final _sel_toggleTabOverview_ = objc.registerName("toggleTabOverview:"); +late final _sel_tabbedWindows = objc.registerName("tabbedWindows"); +late final _sel_addTabbedWindow_ordered_ = + objc.registerName("addTabbedWindow:ordered:"); + +/// NSWindowTab +class NSWindowTab extends objc.ObjCObjectBase { + NSWindowTab._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSWindowTab] that points to the same underlying object as [other]. + NSWindowTab.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSWindowTab] that wraps the given raw object pointer. + NSWindowTab.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSWindowTab]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSWindowTab); + } +} + +late final _class_NSWindowTab = objc.getClass("NSWindowTab"); +late final _sel_tab = objc.registerName("tab"); +final _objc_msgSend_255 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSWindowTabGroup +class NSWindowTabGroup extends objc.ObjCObjectBase { + NSWindowTabGroup._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSWindowTabGroup] that points to the same underlying object as [other]. + NSWindowTabGroup.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSWindowTabGroup] that wraps the given raw object pointer. + NSWindowTabGroup.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSWindowTabGroup]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSWindowTabGroup); + } +} + +late final _class_NSWindowTabGroup = objc.getClass("NSWindowTabGroup"); +late final _sel_tabGroup = objc.registerName("tabGroup"); +final _objc_msgSend_256 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +void _ObjCBlock_ffiVoid_NSError_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_NSError_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_NSError extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSError._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSError castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSError._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSError.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSError_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSError.fromFunction(void Function(objc.NSError?) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSError_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0.address == 0 + ? null + : objc.NSError.castFromPointer(arg0, + retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSError.listener(void Function(objc.NSError?) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSError(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSError_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn(arg0.address == 0 + ? null + : objc.NSError.castFromPointer(arg0, + retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(objc.NSError? arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function( + ffi.Pointer, ffi.Pointer)>()( + pointer, arg0?.pointer ?? ffi.nullptr); +} + +late final _sel_transferWindowSharingToWindow_completionHandler_ = + objc.registerName("transferWindowSharingToWindow:completionHandler:"); +final _objc_msgSend_257 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_hasActiveWindowSharingSession = + objc.registerName("hasActiveWindowSharingSession"); +late final _sel_windowTitlebarLayoutDirection = + objc.registerName("windowTitlebarLayoutDirection"); +void _ObjCBlock_ffiVoid_NSEvent_bool_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +void _ObjCBlock_ffiVoid_NSEvent_bool_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_ffiVoid_NSEvent_bool extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSEvent_bool._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSEvent_bool castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSEvent_bool._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSEvent_bool.fromFunctionPointer( + ffi.Pointer arg0, ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSEvent_bool_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSEvent_bool.fromFunction( + void Function(NSEvent?, ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSEvent_bool_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0.address == 0 + ? null + : NSEvent.castFromPointer(arg0, retain: true, release: true), + arg1))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSEvent_bool.listener( + void Function(NSEvent?, ffi.Pointer) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSEvent_bool(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSEvent_bool_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0.address == 0 ? null : NSEvent.castFromPointer(arg0, retain: false, release: true), arg1)))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(NSEvent? arg0, ffi.Pointer arg1) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>()( + pointer, arg0?.pointer ?? ffi.nullptr, arg1); +} + +late final _sel_trackEventsMatchingMask_timeout_mode_handler_ = + objc.registerName("trackEventsMatchingMask:timeout:mode:handler:"); +final _objc_msgSend_258 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.LongLong, + ffi.Double, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + int, + double, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_nextEventMatchingMask_ = + objc.registerName("nextEventMatchingMask:"); +final _objc_msgSend_259 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.LongLong)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_nextEventMatchingMask_untilDate_inMode_dequeue_ = + objc.registerName("nextEventMatchingMask:untilDate:inMode:dequeue:"); +final _objc_msgSend_260 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.LongLong, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_discardEventsMatchingMask_beforeEvent_ = + objc.registerName("discardEventsMatchingMask:beforeEvent:"); +final _objc_msgSend_261 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.LongLong, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_postEvent_atStart_ = objc.registerName("postEvent:atStart:"); +final _objc_msgSend_262 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_sendEvent_ = objc.registerName("sendEvent:"); +late final _sel_currentEvent = objc.registerName("currentEvent"); +final _objc_msgSend_263 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_acceptsMouseMovedEvents = + objc.registerName("acceptsMouseMovedEvents"); +late final _sel_setAcceptsMouseMovedEvents_ = + objc.registerName("setAcceptsMouseMovedEvents:"); +late final _sel_ignoresMouseEvents = objc.registerName("ignoresMouseEvents"); +late final _sel_setIgnoresMouseEvents_ = + objc.registerName("setIgnoresMouseEvents:"); +late final _sel_mouseLocationOutsideOfEventStream = + objc.registerName("mouseLocationOutsideOfEventStream"); +late final _sel_disableCursorRects = objc.registerName("disableCursorRects"); +late final _sel_enableCursorRects = objc.registerName("enableCursorRects"); +late final _sel_discardCursorRects = objc.registerName("discardCursorRects"); +late final _sel_areCursorRectsEnabled = + objc.registerName("areCursorRectsEnabled"); +late final _sel_invalidateCursorRectsForView_ = + objc.registerName("invalidateCursorRectsForView:"); +late final _sel_resetCursorRects = objc.registerName("resetCursorRects"); + +/// NSPasteboard +class NSPasteboard extends objc.NSObject { + NSPasteboard._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSPasteboard] that points to the same underlying object as [other]. + NSPasteboard.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSPasteboard] that wraps the given raw object pointer. + NSPasteboard.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSPasteboard]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSPasteboard); + } + + /// generalPasteboard + static NSPasteboard getGeneralPasteboard() { + final _ret = _objc_msgSend_264(_class_NSPasteboard, _sel_generalPasteboard); + return NSPasteboard.castFromPointer(_ret, retain: true, release: true); + } + + /// pasteboardWithName: + static NSPasteboard pasteboardWithName_(objc.NSString name) { + final _ret = _objc_msgSend_265( + _class_NSPasteboard, _sel_pasteboardWithName_, name.pointer); + return NSPasteboard.castFromPointer(_ret, retain: true, release: true); + } + + /// pasteboardWithUniqueName + static NSPasteboard pasteboardWithUniqueName() { + final _ret = + _objc_msgSend_264(_class_NSPasteboard, _sel_pasteboardWithUniqueName); + return NSPasteboard.castFromPointer(_ret, retain: true, release: true); + } + + /// name + objc.NSString get name { + final _ret = _objc_msgSend_13(this.pointer, _sel_name); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// changeCount + int get changeCount { + return _objc_msgSend_67(this.pointer, _sel_changeCount); + } + + /// releaseGlobally + void releaseGlobally() { + _objc_msgSend_5(this.pointer, _sel_releaseGlobally); + } + + /// prepareForNewContentsWithOptions: + int prepareForNewContentsWithOptions_(NSPasteboardContentsOptions options) { + return _objc_msgSend_266( + this.pointer, _sel_prepareForNewContentsWithOptions_, options.value); + } + + /// clearContents + int clearContents() { + return _objc_msgSend_67(this.pointer, _sel_clearContents); + } + + /// writeObjects: + bool writeObjects_(objc.NSArray objects) { + return _objc_msgSend_267(this.pointer, _sel_writeObjects_, objects.pointer); + } + + /// readObjectsForClasses:options: + objc.NSArray? readObjectsForClasses_options_( + objc.NSArray classArray, objc.NSDictionary? options) { + final _ret = _objc_msgSend_268( + this.pointer, + _sel_readObjectsForClasses_options_, + classArray.pointer, + options?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// pasteboardItems + objc.NSArray? get pasteboardItems { + final _ret = _objc_msgSend_232(this.pointer, _sel_pasteboardItems); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// indexOfPasteboardItem: + int indexOfPasteboardItem_(NSPasteboardItem pasteboardItem) { + return _objc_msgSend_269( + this.pointer, _sel_indexOfPasteboardItem_, pasteboardItem.pointer); + } + + /// canReadItemWithDataConformingToTypes: + bool canReadItemWithDataConformingToTypes_(objc.NSArray types) { + return _objc_msgSend_267(this.pointer, + _sel_canReadItemWithDataConformingToTypes_, types.pointer); + } + + /// canReadObjectForClasses:options: + bool canReadObjectForClasses_options_( + objc.NSArray classArray, objc.NSDictionary? options) { + return _objc_msgSend_270( + this.pointer, + _sel_canReadObjectForClasses_options_, + classArray.pointer, + options?.pointer ?? ffi.nullptr); + } + + /// declareTypes:owner: + int declareTypes_owner_( + objc.NSArray newTypes, objc.ObjCObjectBase? newOwner) { + return _objc_msgSend_271(this.pointer, _sel_declareTypes_owner_, + newTypes.pointer, newOwner?.pointer ?? ffi.nullptr); + } + + /// addTypes:owner: + int addTypes_owner_(objc.NSArray newTypes, objc.ObjCObjectBase? newOwner) { + return _objc_msgSend_271(this.pointer, _sel_addTypes_owner_, + newTypes.pointer, newOwner?.pointer ?? ffi.nullptr); + } + + /// types + objc.NSArray? get types { + final _ret = _objc_msgSend_232(this.pointer, _sel_types); + return _ret.address == 0 + ? null + : objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// availableTypeFromArray: + objc.NSString? availableTypeFromArray_(objc.NSArray types) { + final _ret = _objc_msgSend_272( + this.pointer, _sel_availableTypeFromArray_, types.pointer); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setData:forType: + bool setData_forType_(objc.NSData? data, objc.NSString dataType) { + return _objc_msgSend_273(this.pointer, _sel_setData_forType_, + data?.pointer ?? ffi.nullptr, dataType.pointer); + } + + /// setPropertyList:forType: + bool setPropertyList_forType_( + objc.ObjCObjectBase plist, objc.NSString dataType) { + return _objc_msgSend_274(this.pointer, _sel_setPropertyList_forType_, + plist.pointer, dataType.pointer); + } + + /// setString:forType: + bool setString_forType_(objc.NSString string, objc.NSString dataType) { + return _objc_msgSend_275(this.pointer, _sel_setString_forType_, + string.pointer, dataType.pointer); + } + + /// dataForType: + objc.NSData? dataForType_(objc.NSString dataType) { + final _ret = + _objc_msgSend_276(this.pointer, _sel_dataForType_, dataType.pointer); + return _ret.address == 0 + ? null + : objc.NSData.castFromPointer(_ret, retain: true, release: true); + } + + /// propertyListForType: + objc.ObjCObjectBase? propertyListForType_(objc.NSString dataType) { + final _ret = _objc_msgSend_277( + this.pointer, _sel_propertyListForType_, dataType.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// stringForType: + objc.NSString? stringForType_(objc.NSString dataType) { + final _ret = + _objc_msgSend_278(this.pointer, _sel_stringForType_, dataType.pointer); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSPasteboard init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSPasteboard.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSPasteboard new1() { + final _ret = _objc_msgSend_34(_class_NSPasteboard, _sel_new); + return NSPasteboard.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSPasteboard allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSPasteboard, _sel_allocWithZone_, zone); + return NSPasteboard.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSPasteboard alloc() { + final _ret = _objc_msgSend_34(_class_NSPasteboard, _sel_alloc); + return NSPasteboard.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSPasteboard = objc.getClass("NSPasteboard"); +late final _sel_generalPasteboard = objc.registerName("generalPasteboard"); +final _objc_msgSend_264 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_pasteboardWithName_ = objc.registerName("pasteboardWithName:"); +final _objc_msgSend_265 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_pasteboardWithUniqueName = + objc.registerName("pasteboardWithUniqueName"); +late final _sel_name = objc.registerName("name"); +late final _sel_changeCount = objc.registerName("changeCount"); +late final _sel_releaseGlobally = objc.registerName("releaseGlobally"); + +enum NSPasteboardContentsOptions { + NSPasteboardContentsCurrentHostOnly(1); + + final int value; + const NSPasteboardContentsOptions(this.value); + + static NSPasteboardContentsOptions fromValue(int value) => switch (value) { + 1 => NSPasteboardContentsCurrentHostOnly, + _ => throw ArgumentError( + "Unknown value for NSPasteboardContentsOptions: $value"), + }; +} + +late final _sel_prepareForNewContentsWithOptions_ = + objc.registerName("prepareForNewContentsWithOptions:"); +final _objc_msgSend_266 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_clearContents = objc.registerName("clearContents"); +late final _sel_writeObjects_ = objc.registerName("writeObjects:"); +final _objc_msgSend_267 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_readObjectsForClasses_options_ = + objc.registerName("readObjectsForClasses:options:"); +final _objc_msgSend_268 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pasteboardItems = objc.registerName("pasteboardItems"); + +/// NSPasteboardItem +class NSPasteboardItem extends objc.ObjCObjectBase { + NSPasteboardItem._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [NSPasteboardItem] that points to the same underlying object as [other]. + NSPasteboardItem.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSPasteboardItem] that wraps the given raw object pointer. + NSPasteboardItem.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSPasteboardItem]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSPasteboardItem); + } +} + +late final _class_NSPasteboardItem = objc.getClass("NSPasteboardItem"); +late final _sel_indexOfPasteboardItem_ = + objc.registerName("indexOfPasteboardItem:"); +final _objc_msgSend_269 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_canReadItemWithDataConformingToTypes_ = + objc.registerName("canReadItemWithDataConformingToTypes:"); +late final _sel_canReadObjectForClasses_options_ = + objc.registerName("canReadObjectForClasses:options:"); +final _objc_msgSend_270 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_declareTypes_owner_ = objc.registerName("declareTypes:owner:"); +final _objc_msgSend_271 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_addTypes_owner_ = objc.registerName("addTypes:owner:"); +late final _sel_types = objc.registerName("types"); +late final _sel_availableTypeFromArray_ = + objc.registerName("availableTypeFromArray:"); +final _objc_msgSend_272 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setData_forType_ = objc.registerName("setData:forType:"); +final _objc_msgSend_273 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_setPropertyList_forType_ = + objc.registerName("setPropertyList:forType:"); +final _objc_msgSend_274 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_setString_forType_ = objc.registerName("setString:forType:"); +final _objc_msgSend_275 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_dataForType_ = objc.registerName("dataForType:"); +final _objc_msgSend_276 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_propertyListForType_ = + objc.registerName("propertyListForType:"); +final _objc_msgSend_277 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_stringForType_ = objc.registerName("stringForType:"); +final _objc_msgSend_278 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_dragImage_at_offset_event_pasteboard_source_slideBack_ = + objc.registerName("dragImage:at:offset:event:pasteboard:source:slideBack:"); +final _objc_msgSend_279 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + CGSize, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + CGPoint, + CGSize, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_registerForDraggedTypes_ = + objc.registerName("registerForDraggedTypes:"); +final _objc_msgSend_280 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_unregisterDraggedTypes = + objc.registerName("unregisterDraggedTypes"); +late final _sel_initWithWindowRef_ = objc.registerName("initWithWindowRef:"); +final _objc_msgSend_281 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_windowRef = objc.registerName("windowRef"); + +/// CADisplayLink +class CADisplayLink extends objc.ObjCObjectBase { + CADisplayLink._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [CADisplayLink] that points to the same underlying object as [other]. + CADisplayLink.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CADisplayLink] that wraps the given raw object pointer. + CADisplayLink.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CADisplayLink]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_CADisplayLink); + } +} + +late final _class_CADisplayLink = objc.getClass("CADisplayLink"); +late final _sel_displayLinkWithTarget_selector_ = + objc.registerName("displayLinkWithTarget:selector:"); +final _objc_msgSend_282 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_cacheImageInRect_ = objc.registerName("cacheImageInRect:"); +late final _sel_restoreCachedImage = objc.registerName("restoreCachedImage"); +late final _sel_discardCachedImage = objc.registerName("discardCachedImage"); +late final _sel_menuChanged_ = objc.registerName("menuChanged:"); +final _objc_msgSend_283 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_gState = objc.registerName("gState"); +late final _sel_convertBaseToScreen_ = + objc.registerName("convertBaseToScreen:"); +late final _sel_convertScreenToBase_ = + objc.registerName("convertScreenToBase:"); +late final _sel_userSpaceScaleFactor = + objc.registerName("userSpaceScaleFactor"); +late final _sel_useOptimizedDrawing_ = + objc.registerName("useOptimizedDrawing:"); +late final _sel_canStoreColor = objc.registerName("canStoreColor"); +late final _sel_disableFlushWindow = objc.registerName("disableFlushWindow"); +late final _sel_enableFlushWindow = objc.registerName("enableFlushWindow"); +late final _sel_isFlushWindowDisabled = + objc.registerName("isFlushWindowDisabled"); +late final _sel_flushWindow = objc.registerName("flushWindow"); +late final _sel_flushWindowIfNeeded = objc.registerName("flushWindowIfNeeded"); +late final _sel_isAutodisplay = objc.registerName("isAutodisplay"); +late final _sel_setAutodisplay_ = objc.registerName("setAutodisplay:"); +late final _sel_graphicsContext = objc.registerName("graphicsContext"); +late final _sel_isOneShot = objc.registerName("isOneShot"); +late final _sel_setOneShot_ = objc.registerName("setOneShot:"); + +enum NSWindowBackingLocation { + /// System determines if window backing store is in VRAM or main memory + NSWindowBackingLocationDefault(0), + + /// Window backing store is in VRAM + NSWindowBackingLocationVideoMemory(1), + + /// Window backing store is in main memory + NSWindowBackingLocationMainMemory(2); + + final int value; + const NSWindowBackingLocation(this.value); + + static NSWindowBackingLocation fromValue(int value) => switch (value) { + 0 => NSWindowBackingLocationDefault, + 1 => NSWindowBackingLocationVideoMemory, + 2 => NSWindowBackingLocationMainMemory, + _ => throw ArgumentError( + "Unknown value for NSWindowBackingLocation: $value"), + }; +} + +late final _sel_preferredBackingLocation = + objc.registerName("preferredBackingLocation"); +final _objc_msgSend_284 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setPreferredBackingLocation_ = + objc.registerName("setPreferredBackingLocation:"); +final _objc_msgSend_285 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_backingLocation = objc.registerName("backingLocation"); +late final _sel_showsResizeIndicator = + objc.registerName("showsResizeIndicator"); +late final _sel_setShowsResizeIndicator_ = + objc.registerName("setShowsResizeIndicator:"); +late final _sel_windowWithWindowNumber_ = + objc.registerName("windowWithWindowNumber:"); +final _objc_msgSend_286 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Long)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_mainWindow = objc.registerName("mainWindow"); +late final _sel_keyWindow = objc.registerName("keyWindow"); +late final _sel_isActive = objc.registerName("isActive"); +late final _sel_isRunning = objc.registerName("isRunning"); +late final _sel_deactivate = objc.registerName("deactivate"); +late final _sel_activateIgnoringOtherApps_ = + objc.registerName("activateIgnoringOtherApps:"); +late final _sel_activate = objc.registerName("activate"); + +/// NSRunningApplication +class NSRunningApplication extends objc.NSObject { + NSRunningApplication._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSRunningApplication] that points to the same underlying object as [other]. + NSRunningApplication.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSRunningApplication] that wraps the given raw object pointer. + NSRunningApplication.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSRunningApplication]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSRunningApplication); + } + + /// isTerminated + bool get terminated { + return _objc_msgSend_17(this.pointer, _sel_isTerminated); + } + + /// isFinishedLaunching + bool get finishedLaunching { + return _objc_msgSend_17(this.pointer, _sel_isFinishedLaunching); + } + + /// isHidden + bool get hidden { + return _objc_msgSend_17(this.pointer, _sel_isHidden); + } + + /// isActive + bool get active { + return _objc_msgSend_17(this.pointer, _sel_isActive); + } + + /// ownsMenuBar + bool get ownsMenuBar { + return _objc_msgSend_17(this.pointer, _sel_ownsMenuBar); + } + + /// activationPolicy + NSApplicationActivationPolicy get activationPolicy { + final _ret = _objc_msgSend_287(this.pointer, _sel_activationPolicy); + return NSApplicationActivationPolicy.fromValue(_ret); + } + + /// localizedName + objc.NSString? get localizedName { + final _ret = _objc_msgSend_72(this.pointer, _sel_localizedName); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleIdentifier + objc.NSString? get bundleIdentifier { + final _ret = _objc_msgSend_72(this.pointer, _sel_bundleIdentifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleURL + objc.NSURL? get bundleURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_bundleURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// executableURL + objc.NSURL? get executableURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_executableURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// processIdentifier + int get processIdentifier { + return _objc_msgSend_288(this.pointer, _sel_processIdentifier); + } + + /// launchDate + objc.NSDate? get launchDate { + final _ret = _objc_msgSend_289(this.pointer, _sel_launchDate); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// icon + NSImage? get icon { + final _ret = _objc_msgSend_132(this.pointer, _sel_icon); + return _ret.address == 0 + ? null + : NSImage.castFromPointer(_ret, retain: true, release: true); + } + + /// executableArchitecture + int get executableArchitecture { + return _objc_msgSend_67(this.pointer, _sel_executableArchitecture); + } + + /// hide + bool hide1() { + return _objc_msgSend_17(this.pointer, _sel_hide); + } + + /// unhide + bool unhide() { + return _objc_msgSend_17(this.pointer, _sel_unhide); + } + + /// activateFromApplication:options: + bool activateFromApplication_options_(NSRunningApplication application, + NSApplicationActivationOptions options) { + return _objc_msgSend_290( + this.pointer, + _sel_activateFromApplication_options_, + application.pointer, + options.value); + } + + /// activateWithOptions: + bool activateWithOptions_(NSApplicationActivationOptions options) { + return _objc_msgSend_291( + this.pointer, _sel_activateWithOptions_, options.value); + } + + /// terminate + bool terminate() { + return _objc_msgSend_17(this.pointer, _sel_terminate); + } + + /// forceTerminate + bool forceTerminate() { + return _objc_msgSend_17(this.pointer, _sel_forceTerminate); + } + + /// runningApplicationsWithBundleIdentifier: + static objc.ObjCObjectBase runningApplicationsWithBundleIdentifier_( + objc.NSString bundleIdentifier) { + final _ret = _objc_msgSend_120( + _class_NSRunningApplication, + _sel_runningApplicationsWithBundleIdentifier_, + bundleIdentifier.pointer); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// runningApplicationWithProcessIdentifier: + static NSRunningApplication? runningApplicationWithProcessIdentifier_( + int pid) { + final _ret = _objc_msgSend_292(_class_NSRunningApplication, + _sel_runningApplicationWithProcessIdentifier_, pid); + return _ret.address == 0 + ? null + : NSRunningApplication.castFromPointer(_ret, + retain: true, release: true); + } + + /// currentApplication + static NSRunningApplication getCurrentApplication() { + final _ret = + _objc_msgSend_293(_class_NSRunningApplication, _sel_currentApplication); + return NSRunningApplication.castFromPointer(_ret, + retain: true, release: true); + } + + /// terminateAutomaticallyTerminableApplications + static void terminateAutomaticallyTerminableApplications() { + _objc_msgSend_5(_class_NSRunningApplication, + _sel_terminateAutomaticallyTerminableApplications); + } + + /// init + NSRunningApplication init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSRunningApplication.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static NSRunningApplication new1() { + final _ret = _objc_msgSend_34(_class_NSRunningApplication, _sel_new); + return NSRunningApplication.castFromPointer(_ret, + retain: false, release: true); + } + + /// allocWithZone: + static NSRunningApplication allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89( + _class_NSRunningApplication, _sel_allocWithZone_, zone); + return NSRunningApplication.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static NSRunningApplication alloc() { + final _ret = _objc_msgSend_34(_class_NSRunningApplication, _sel_alloc); + return NSRunningApplication.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_NSRunningApplication = objc.getClass("NSRunningApplication"); +late final _sel_isTerminated = objc.registerName("isTerminated"); +late final _sel_isFinishedLaunching = objc.registerName("isFinishedLaunching"); +late final _sel_ownsMenuBar = objc.registerName("ownsMenuBar"); + +enum NSApplicationActivationPolicy { + NSApplicationActivationPolicyRegular(0), + NSApplicationActivationPolicyAccessory(1), + NSApplicationActivationPolicyProhibited(2); + + final int value; + const NSApplicationActivationPolicy(this.value); + + static NSApplicationActivationPolicy fromValue(int value) => switch (value) { + 0 => NSApplicationActivationPolicyRegular, + 1 => NSApplicationActivationPolicyAccessory, + 2 => NSApplicationActivationPolicyProhibited, + _ => throw ArgumentError( + "Unknown value for NSApplicationActivationPolicy: $value"), + }; +} + +late final _sel_activationPolicy = objc.registerName("activationPolicy"); +final _objc_msgSend_287 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_localizedName = objc.registerName("localizedName"); +late final _sel_bundleIdentifier = objc.registerName("bundleIdentifier"); +late final _sel_bundleURL = objc.registerName("bundleURL"); +late final _sel_executableURL = objc.registerName("executableURL"); +late final _sel_processIdentifier = objc.registerName("processIdentifier"); +final _objc_msgSend_288 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Int Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_launchDate = objc.registerName("launchDate"); +final _objc_msgSend_289 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_icon = objc.registerName("icon"); +late final _sel_executableArchitecture = + objc.registerName("executableArchitecture"); +late final _sel_hide = objc.registerName("hide"); +late final _sel_unhide = objc.registerName("unhide"); + +enum NSApplicationActivationOptions { + NSApplicationActivateAllWindows(1), + NSApplicationActivateIgnoringOtherApps(2); + + final int value; + const NSApplicationActivationOptions(this.value); + + static NSApplicationActivationOptions fromValue(int value) => switch (value) { + 1 => NSApplicationActivateAllWindows, + 2 => NSApplicationActivateIgnoringOtherApps, + _ => throw ArgumentError( + "Unknown value for NSApplicationActivationOptions: $value"), + }; +} + +late final _sel_activateFromApplication_options_ = + objc.registerName("activateFromApplication:options:"); +final _objc_msgSend_290 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_activateWithOptions_ = + objc.registerName("activateWithOptions:"); +final _objc_msgSend_291 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_terminate = objc.registerName("terminate"); +late final _sel_forceTerminate = objc.registerName("forceTerminate"); +late final _sel_runningApplicationsWithBundleIdentifier_ = + objc.registerName("runningApplicationsWithBundleIdentifier:"); +late final _sel_runningApplicationWithProcessIdentifier_ = + objc.registerName("runningApplicationWithProcessIdentifier:"); +final _objc_msgSend_292 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Int)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_currentApplication = objc.registerName("currentApplication"); +final _objc_msgSend_293 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_terminateAutomaticallyTerminableApplications = + objc.registerName("terminateAutomaticallyTerminableApplications"); +late final _sel_yieldActivationToApplication_ = + objc.registerName("yieldActivationToApplication:"); +final _objc_msgSend_294 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_yieldActivationToApplicationWithBundleIdentifier_ = + objc.registerName("yieldActivationToApplicationWithBundleIdentifier:"); +late final _sel_hideOtherApplications_ = + objc.registerName("hideOtherApplications:"); +late final _sel_unhideAllApplications_ = + objc.registerName("unhideAllApplications:"); +late final _sel_finishLaunching = objc.registerName("finishLaunching"); +late final _sel_run = objc.registerName("run"); +late final _sel_runModalForWindow_ = objc.registerName("runModalForWindow:"); +final _objc_msgSend_295 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_stop_ = objc.registerName("stop:"); +late final _sel_stopModal = objc.registerName("stopModal"); +late final _sel_stopModalWithCode_ = objc.registerName("stopModalWithCode:"); +late final _sel_abortModal = objc.registerName("abortModal"); +late final _sel_modalWindow = objc.registerName("modalWindow"); + +final class _NSModalSession extends ffi.Opaque {} + +late final _sel_beginModalSessionForWindow_ = + objc.registerName("beginModalSessionForWindow:"); +final _objc_msgSend_296 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer<_NSModalSession> Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer<_NSModalSession> Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_runModalSession_ = objc.registerName("runModalSession:"); +final _objc_msgSend_297 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<_NSModalSession>)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<_NSModalSession>)>(); +late final _sel_endModalSession_ = objc.registerName("endModalSession:"); +final _objc_msgSend_298 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer<_NSModalSession>)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer<_NSModalSession>)>(); +late final _sel_terminate_ = objc.registerName("terminate:"); + +enum NSRequestUserAttentionType { + NSCriticalRequest(0), + NSInformationalRequest(10); + + final int value; + const NSRequestUserAttentionType(this.value); + + static NSRequestUserAttentionType fromValue(int value) => switch (value) { + 0 => NSCriticalRequest, + 10 => NSInformationalRequest, + _ => throw ArgumentError( + "Unknown value for NSRequestUserAttentionType: $value"), + }; +} + +late final _sel_requestUserAttention_ = + objc.registerName("requestUserAttention:"); +final _objc_msgSend_299 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_cancelUserAttentionRequest_ = + objc.registerName("cancelUserAttentionRequest:"); + +enum NSWindowListOptions { + /// Onscreen application windows in front to back order. By default, -[NSApp windows] is used. + NSWindowListOrderedFrontToBack(1); + + final int value; + const NSWindowListOptions(this.value); + + static NSWindowListOptions fromValue(int value) => switch (value) { + 1 => NSWindowListOrderedFrontToBack, + _ => + throw ArgumentError("Unknown value for NSWindowListOptions: $value"), + }; +} + +void _ObjCBlock_ffiVoid_NSWindow_bool_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +void _ObjCBlock_ffiVoid_NSWindow_bool_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_ffiVoid_NSWindow_bool extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSWindow_bool._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSWindow_bool castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSWindow_bool._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSWindow_bool.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._( + objc + .newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSWindow_bool_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSWindow_bool.fromFunction( + void Function(NSWindow, ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSWindow_bool_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => + fn(NSWindow.castFromPointer(arg0, retain: true, release: true), + arg1))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSWindow_bool.listener( + void Function(NSWindow, ffi.Pointer) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSWindow_bool(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSWindow_bool_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + NSWindow.castFromPointer(arg0, retain: false, release: true), + arg1)))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(NSWindow arg0, ffi.Pointer arg1) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(pointer, arg0.pointer, arg1); +} + +late final _sel_enumerateWindowsWithOptions_usingBlock_ = + objc.registerName("enumerateWindowsWithOptions:usingBlock:"); +final _objc_msgSend_300 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer)>(); +late final _sel_preventWindowOrdering = + objc.registerName("preventWindowOrdering"); +late final _sel_windows = objc.registerName("windows"); +late final _sel_setWindowsNeedUpdate_ = + objc.registerName("setWindowsNeedUpdate:"); +late final _sel_updateWindows = objc.registerName("updateWindows"); +late final _sel_mainMenu = objc.registerName("mainMenu"); +late final _sel_setMainMenu_ = objc.registerName("setMainMenu:"); +late final _sel_helpMenu = objc.registerName("helpMenu"); +late final _sel_setHelpMenu_ = objc.registerName("setHelpMenu:"); +late final _sel_applicationIconImage = + objc.registerName("applicationIconImage"); +late final _sel_setApplicationIconImage_ = + objc.registerName("setApplicationIconImage:"); +late final _sel_setActivationPolicy_ = + objc.registerName("setActivationPolicy:"); +final _objc_msgSend_301 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, int)>(); + +/// NSException +class NSException extends objc.NSObject { + NSException._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSException] that points to the same underlying object as [other]. + NSException.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSException] that wraps the given raw object pointer. + NSException.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSException]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSException); + } + + /// exceptionWithName:reason:userInfo: + static NSException exceptionWithName_reason_userInfo_( + objc.NSString name, objc.NSString? reason, objc.NSDictionary? userInfo) { + final _ret = _objc_msgSend_302( + _class_NSException, + _sel_exceptionWithName_reason_userInfo_, + name.pointer, + reason?.pointer ?? ffi.nullptr, + userInfo?.pointer ?? ffi.nullptr); + return NSException.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithName:reason:userInfo: + NSException initWithName_reason_userInfo_(objc.NSString aName, + objc.NSString? aReason, objc.NSDictionary? aUserInfo) { + final _ret = _objc_msgSend_303( + this.pointer, + _sel_initWithName_reason_userInfo_, + aName.pointer, + aReason?.pointer ?? ffi.nullptr, + aUserInfo?.pointer ?? ffi.nullptr); + return NSException.castFromPointer(_ret, retain: true, release: true); + } + + /// name + objc.NSString get name { + final _ret = _objc_msgSend_13(this.pointer, _sel_name); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// reason + objc.NSString? get reason { + final _ret = _objc_msgSend_72(this.pointer, _sel_reason); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// userInfo + objc.NSDictionary? get userInfo { + final _ret = _objc_msgSend_304(this.pointer, _sel_userInfo); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// callStackReturnAddresses + objc.ObjCObjectBase get callStackReturnAddresses { + final _ret = _objc_msgSend_34(this.pointer, _sel_callStackReturnAddresses); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// callStackSymbols + objc.ObjCObjectBase get callStackSymbols { + final _ret = _objc_msgSend_34(this.pointer, _sel_callStackSymbols); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// raise + void raise() { + _objc_msgSend_5(this.pointer, _sel_raise); + } + + /// init + NSException init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSException.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSException new1() { + final _ret = _objc_msgSend_34(_class_NSException, _sel_new); + return NSException.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSException allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSException, _sel_allocWithZone_, zone); + return NSException.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSException alloc() { + final _ret = _objc_msgSend_34(_class_NSException, _sel_alloc); + return NSException.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSException = objc.getClass("NSException"); +late final _sel_exceptionWithName_reason_userInfo_ = + objc.registerName("exceptionWithName:reason:userInfo:"); +final _objc_msgSend_302 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithName_reason_userInfo_ = + objc.registerName("initWithName:reason:userInfo:"); +final _objc_msgSend_303 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_reason = objc.registerName("reason"); +late final _sel_userInfo = objc.registerName("userInfo"); +final _objc_msgSend_304 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_callStackReturnAddresses = + objc.registerName("callStackReturnAddresses"); +late final _sel_callStackSymbols = objc.registerName("callStackSymbols"); +late final _sel_raise = objc.registerName("raise"); +late final _sel_reportException_ = objc.registerName("reportException:"); +final _objc_msgSend_305 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_detachDrawingThread_toTarget_withObject_ = + objc.registerName("detachDrawingThread:toTarget:withObject:"); +final _objc_msgSend_306 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_replyToApplicationShouldTerminate_ = + objc.registerName("replyToApplicationShouldTerminate:"); + +enum NSApplicationDelegateReply { + NSApplicationDelegateReplySuccess(0), + NSApplicationDelegateReplyCancel(1), + NSApplicationDelegateReplyFailure(2); + + final int value; + const NSApplicationDelegateReply(this.value); + + static NSApplicationDelegateReply fromValue(int value) => switch (value) { + 0 => NSApplicationDelegateReplySuccess, + 1 => NSApplicationDelegateReplyCancel, + 2 => NSApplicationDelegateReplyFailure, + _ => throw ArgumentError( + "Unknown value for NSApplicationDelegateReply: $value"), + }; +} + +late final _sel_replyToOpenOrPrint_ = objc.registerName("replyToOpenOrPrint:"); +final _objc_msgSend_307 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_orderFrontCharacterPalette_ = + objc.registerName("orderFrontCharacterPalette:"); + +/// Flags that comprise an application's @c presentationOptions. +enum NSApplicationPresentationOptions { + NSApplicationPresentationDefault(0), + + /// Dock appears when moused to. + NSApplicationPresentationAutoHideDock(1), + + /// Dock is entirely unavailable. + NSApplicationPresentationHideDock(2), + + /// Menu Bar appears when moused to. + NSApplicationPresentationAutoHideMenuBar(4), + + /// Menu Bar is entirely unavailable. + NSApplicationPresentationHideMenuBar(8), + + /// All Apple menu items are disabled. + NSApplicationPresentationDisableAppleMenu(16), + + /// Cmd+Tab UI is disabled. + NSApplicationPresentationDisableProcessSwitching(32), + + /// Cmd+Opt+Esc panel is disabled. + NSApplicationPresentationDisableForceQuit(64), + + /// PowerKey panel and Restart/Shut Down/Log Out disabled. + NSApplicationPresentationDisableSessionTermination(128), + + /// Application "Hide" menu item is disabled. + NSApplicationPresentationDisableHideApplication(256), + + /// Menu Bar's transparent appearance is disabled. + NSApplicationPresentationDisableMenuBarTransparency(512), + + /// Application is in fullscreen mode. + NSApplicationPresentationFullScreen(1024), + + /// Fullscreen window toolbar is detached from window and hides/shows on rollover. + /// May be used only when both @c NSApplicationPresentationFullScreen is also set. + NSApplicationPresentationAutoHideToolbar(2048), + + /// "Shake mouse pointer to locate" is disabled for this application. + NSApplicationPresentationDisableCursorLocationAssistance(4096); + + final int value; + const NSApplicationPresentationOptions(this.value); + + static NSApplicationPresentationOptions fromValue(int value) => + switch (value) { + 0 => NSApplicationPresentationDefault, + 1 => NSApplicationPresentationAutoHideDock, + 2 => NSApplicationPresentationHideDock, + 4 => NSApplicationPresentationAutoHideMenuBar, + 8 => NSApplicationPresentationHideMenuBar, + 16 => NSApplicationPresentationDisableAppleMenu, + 32 => NSApplicationPresentationDisableProcessSwitching, + 64 => NSApplicationPresentationDisableForceQuit, + 128 => NSApplicationPresentationDisableSessionTermination, + 256 => NSApplicationPresentationDisableHideApplication, + 512 => NSApplicationPresentationDisableMenuBarTransparency, + 1024 => NSApplicationPresentationFullScreen, + 2048 => NSApplicationPresentationAutoHideToolbar, + 4096 => NSApplicationPresentationDisableCursorLocationAssistance, + _ => throw ArgumentError( + "Unknown value for NSApplicationPresentationOptions: $value"), + }; +} + +late final _sel_presentationOptions = objc.registerName("presentationOptions"); +final _objc_msgSend_308 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setPresentationOptions_ = + objc.registerName("setPresentationOptions:"); +final _objc_msgSend_309 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_currentSystemPresentationOptions = + objc.registerName("currentSystemPresentationOptions"); + +enum NSApplicationOcclusionState { + /// If set, at least part of any window owned by this application is visible. If not set, all parts of all windows owned by this application are completely occluded. The menu bar does not count as a window owned by this application, so if only the menu bar is showing then the application is considered not visible. Status items, however, have windows owned by your application. If the status item is present in the menu bar, your application will be considered visible as long as the menu bar is visible. + NSApplicationOcclusionStateVisible(2); + + final int value; + const NSApplicationOcclusionState(this.value); + + static NSApplicationOcclusionState fromValue(int value) => switch (value) { + 2 => NSApplicationOcclusionStateVisible, + _ => throw ArgumentError( + "Unknown value for NSApplicationOcclusionState: $value"), + }; +} + +final _objc_msgSend_310 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isProtectedDataAvailable = + objc.registerName("isProtectedDataAvailable"); + +/// NSAppearance +class NSAppearance extends objc.NSObject { + NSAppearance._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSAppearance] that points to the same underlying object as [other]. + NSAppearance.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSAppearance] that wraps the given raw object pointer. + NSAppearance.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSAppearance]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSAppearance); + } + + /// name + objc.NSString get name { + final _ret = _objc_msgSend_13(this.pointer, _sel_name); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// currentAppearance + static NSAppearance getCurrentAppearance() { + final _ret = _objc_msgSend_311(_class_NSAppearance, _sel_currentAppearance); + return NSAppearance.castFromPointer(_ret, retain: true, release: true); + } + + /// setCurrentAppearance: + static void setCurrentAppearance(NSAppearance value) { + return _objc_msgSend_312( + _class_NSAppearance, _sel_setCurrentAppearance_, value.pointer); + } + + /// currentDrawingAppearance + static NSAppearance getCurrentDrawingAppearance() { + final _ret = + _objc_msgSend_311(_class_NSAppearance, _sel_currentDrawingAppearance); + return NSAppearance.castFromPointer(_ret, retain: true, release: true); + } + + /// performAsCurrentDrawingAppearance: + void performAsCurrentDrawingAppearance_(ObjCBlock_ffiVoid block) { + _objc_msgSend_313( + this.pointer, _sel_performAsCurrentDrawingAppearance_, block.pointer); + } + + /// appearanceNamed: + static NSAppearance? appearanceNamed_(objc.NSString name) { + final _ret = _objc_msgSend_314( + _class_NSAppearance, _sel_appearanceNamed_, name.pointer); + return _ret.address == 0 + ? null + : NSAppearance.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithAppearanceNamed:bundle: + NSAppearance? initWithAppearanceNamed_bundle_( + objc.NSString name, NSBundle? bundle) { + final _ret = _objc_msgSend_337( + this.pointer, + _sel_initWithAppearanceNamed_bundle_, + name.pointer, + bundle?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : NSAppearance.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + NSAppearance? initWithCoder_(objc.NSCoder coder) { + final _ret = + _objc_msgSend_31(this.pointer, _sel_initWithCoder_, coder.pointer); + return _ret.address == 0 + ? null + : NSAppearance.castFromPointer(_ret, retain: true, release: true); + } + + /// allowsVibrancy + bool get allowsVibrancy { + return _objc_msgSend_17(this.pointer, _sel_allowsVibrancy); + } + + /// bestMatchFromAppearancesWithNames: + objc.NSString? bestMatchFromAppearancesWithNames_( + objc.ObjCObjectBase appearances) { + final _ret = _objc_msgSend_338(this.pointer, + _sel_bestMatchFromAppearancesWithNames_, appearances.pointer); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSAppearance init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSAppearance.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSAppearance new1() { + final _ret = _objc_msgSend_34(_class_NSAppearance, _sel_new); + return NSAppearance.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSAppearance allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSAppearance, _sel_allocWithZone_, zone); + return NSAppearance.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSAppearance alloc() { + final _ret = _objc_msgSend_34(_class_NSAppearance, _sel_alloc); + return NSAppearance.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSAppearance = objc.getClass("NSAppearance"); +late final _sel_currentAppearance = objc.registerName("currentAppearance"); +final _objc_msgSend_311 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setCurrentAppearance_ = + objc.registerName("setCurrentAppearance:"); +final _objc_msgSend_312 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_currentDrawingAppearance = + objc.registerName("currentDrawingAppearance"); +void _ObjCBlock_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, +) => + block.ref.target + .cast>() + .asFunction()(); +void _ObjCBlock_ffiVoid_closureTrampoline( + ffi.Pointer block, +) => + (objc.getBlockClosure(block) as void Function())(); + +class ObjCBlock_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_ffiVoid._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid.fromFunctionPointer( + ffi.Pointer> ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer)>( + _ObjCBlock_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid.fromFunction(void Function() fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer)>( + _ObjCBlock_ffiVoid_closureTrampoline) + .cast(), + () => fn())); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid.listener(void Function() fn) + : this._((objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + () => fn()))); + static ffi.NativeCallable)>? + _dartFuncListenerTrampoline; + + void call() => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block)>>() + .asFunction)>()( + pointer, + ); +} + +late final _sel_performAsCurrentDrawingAppearance_ = + objc.registerName("performAsCurrentDrawingAppearance:"); +final _objc_msgSend_313 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_appearanceNamed_ = objc.registerName("appearanceNamed:"); +final _objc_msgSend_314 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// NSBundle +class NSBundle extends objc.NSObject { + NSBundle._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSBundle] that points to the same underlying object as [other]. + NSBundle.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSBundle] that wraps the given raw object pointer. + NSBundle.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSBundle]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSBundle); + } + + /// mainBundle + static NSBundle getMainBundle() { + final _ret = _objc_msgSend_315(_class_NSBundle, _sel_mainBundle); + return NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleWithPath: + static NSBundle? bundleWithPath_(objc.NSString path) { + final _ret = + _objc_msgSend_277(_class_NSBundle, _sel_bundleWithPath_, path.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithPath: + NSBundle? initWithPath_(objc.NSString path) { + final _ret = + _objc_msgSend_277(this.pointer, _sel_initWithPath_, path.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleWithURL: + static NSBundle? bundleWithURL_(objc.NSURL url) { + final _ret = + _objc_msgSend_316(_class_NSBundle, _sel_bundleWithURL_, url.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithURL: + NSBundle? initWithURL_(objc.NSURL url) { + final _ret = + _objc_msgSend_316(this.pointer, _sel_initWithURL_, url.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleForClass: + static NSBundle bundleForClass_(objc.ObjCObjectBase aClass) { + final _ret = _objc_msgSend_317( + _class_NSBundle, _sel_bundleForClass_, aClass.pointer); + return NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// bundleWithIdentifier: + static NSBundle? bundleWithIdentifier_(objc.NSString identifier) { + final _ret = _objc_msgSend_318( + _class_NSBundle, _sel_bundleWithIdentifier_, identifier.pointer); + return _ret.address == 0 + ? null + : NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// allBundles + static objc.ObjCObjectBase getAllBundles() { + final _ret = _objc_msgSend_34(_class_NSBundle, _sel_allBundles); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// allFrameworks + static objc.ObjCObjectBase getAllFrameworks() { + final _ret = _objc_msgSend_34(_class_NSBundle, _sel_allFrameworks); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// load + bool load() { + return _objc_msgSend_17(this.pointer, _sel_load); + } + + /// isLoaded + bool get loaded { + return _objc_msgSend_17(this.pointer, _sel_isLoaded); + } + + /// unload + bool unload() { + return _objc_msgSend_17(this.pointer, _sel_unload); + } + + /// preflightAndReturnError: + bool preflightAndReturnError_( + ffi.Pointer> error) { + return _objc_msgSend_319( + this.pointer, _sel_preflightAndReturnError_, error); + } + + /// loadAndReturnError: + bool loadAndReturnError_(ffi.Pointer> error) { + return _objc_msgSend_319(this.pointer, _sel_loadAndReturnError_, error); + } + + /// bundleURL + objc.NSURL get bundleURL { + final _ret = _objc_msgSend_320(this.pointer, _sel_bundleURL); + return objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// resourceURL + objc.NSURL? get resourceURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_resourceURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// executableURL + objc.NSURL? get executableURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_executableURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLForAuxiliaryExecutable: + objc.NSURL? URLForAuxiliaryExecutable_(objc.NSString executableName) { + final _ret = _objc_msgSend_321( + this.pointer, _sel_URLForAuxiliaryExecutable_, executableName.pointer); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// privateFrameworksURL + objc.NSURL? get privateFrameworksURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_privateFrameworksURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// sharedFrameworksURL + objc.NSURL? get sharedFrameworksURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_sharedFrameworksURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// sharedSupportURL + objc.NSURL? get sharedSupportURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_sharedSupportURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// builtInPlugInsURL + objc.NSURL? get builtInPlugInsURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_builtInPlugInsURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// appStoreReceiptURL + objc.NSURL? get appStoreReceiptURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_appStoreReceiptURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// bundlePath + objc.NSString get bundlePath { + final _ret = _objc_msgSend_13(this.pointer, _sel_bundlePath); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// resourcePath + objc.NSString? get resourcePath { + final _ret = _objc_msgSend_72(this.pointer, _sel_resourcePath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// executablePath + objc.NSString? get executablePath { + final _ret = _objc_msgSend_72(this.pointer, _sel_executablePath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pathForAuxiliaryExecutable: + objc.NSString? pathForAuxiliaryExecutable_(objc.NSString executableName) { + final _ret = _objc_msgSend_278( + this.pointer, _sel_pathForAuxiliaryExecutable_, executableName.pointer); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// privateFrameworksPath + objc.NSString? get privateFrameworksPath { + final _ret = _objc_msgSend_72(this.pointer, _sel_privateFrameworksPath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// sharedFrameworksPath + objc.NSString? get sharedFrameworksPath { + final _ret = _objc_msgSend_72(this.pointer, _sel_sharedFrameworksPath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// sharedSupportPath + objc.NSString? get sharedSupportPath { + final _ret = _objc_msgSend_72(this.pointer, _sel_sharedSupportPath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// builtInPlugInsPath + objc.NSString? get builtInPlugInsPath { + final _ret = _objc_msgSend_72(this.pointer, _sel_builtInPlugInsPath); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// URLForResource:withExtension:subdirectory:inBundleWithURL: + static objc.NSURL? URLForResource_withExtension_subdirectory_inBundleWithURL_( + objc.NSString? name, + objc.NSString? ext, + objc.NSString? subpath, + objc.NSURL bundleURL) { + final _ret = _objc_msgSend_322( + _class_NSBundle, + _sel_URLForResource_withExtension_subdirectory_inBundleWithURL_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + bundleURL.pointer); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLsForResourcesWithExtension:subdirectory:inBundleWithURL: + static objc.ObjCObjectBase? + URLsForResourcesWithExtension_subdirectory_inBundleWithURL_( + objc.NSString? ext, objc.NSString? subpath, objc.NSURL bundleURL) { + final _ret = _objc_msgSend_323( + _class_NSBundle, + _sel_URLsForResourcesWithExtension_subdirectory_inBundleWithURL_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + bundleURL.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// URLForResource:withExtension: + objc.NSURL? URLForResource_withExtension_( + objc.NSString? name, objc.NSString? ext) { + final _ret = _objc_msgSend_324( + this.pointer, + _sel_URLForResource_withExtension_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLForResource:withExtension:subdirectory: + objc.NSURL? URLForResource_withExtension_subdirectory_( + objc.NSString? name, objc.NSString? ext, objc.NSString? subpath) { + final _ret = _objc_msgSend_325( + this.pointer, + _sel_URLForResource_withExtension_subdirectory_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLForResource:withExtension:subdirectory:localization: + objc.NSURL? URLForResource_withExtension_subdirectory_localization_( + objc.NSString? name, + objc.NSString? ext, + objc.NSString? subpath, + objc.NSString? localizationName) { + final _ret = _objc_msgSend_326( + this.pointer, + _sel_URLForResource_withExtension_subdirectory_localization_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + localizationName?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// URLsForResourcesWithExtension:subdirectory: + objc.ObjCObjectBase? URLsForResourcesWithExtension_subdirectory_( + objc.NSString? ext, objc.NSString? subpath) { + final _ret = _objc_msgSend_172( + this.pointer, + _sel_URLsForResourcesWithExtension_subdirectory_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// URLsForResourcesWithExtension:subdirectory:localization: + objc.ObjCObjectBase? URLsForResourcesWithExtension_subdirectory_localization_( + objc.NSString? ext, + objc.NSString? subpath, + objc.NSString? localizationName) { + final _ret = _objc_msgSend_327( + this.pointer, + _sel_URLsForResourcesWithExtension_subdirectory_localization_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + localizationName?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// pathForResource:ofType:inDirectory: + objc.NSString? pathForResource_ofType_inDirectory_( + objc.NSString? name, objc.NSString? ext, objc.NSString? subpath) { + final _ret = _objc_msgSend_328( + this.pointer, + _sel_pathForResource_ofType_inDirectory_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pathsForResourcesOfType:inDirectory: + objc.ObjCObjectBase pathsForResourcesOfType_inDirectory_( + objc.NSString? ext, objc.NSString? subpath) { + final _ret = _objc_msgSend_329( + this.pointer, + _sel_pathsForResourcesOfType_inDirectory_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// pathForResource:ofType: + objc.NSString? pathForResource_ofType_( + objc.NSString? name, objc.NSString? ext) { + final _ret = _objc_msgSend_330(this.pointer, _sel_pathForResource_ofType_, + name?.pointer ?? ffi.nullptr, ext?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pathForResource:ofType:inDirectory:forLocalization: + objc.NSString? pathForResource_ofType_inDirectory_forLocalization_( + objc.NSString? name, + objc.NSString? ext, + objc.NSString? subpath, + objc.NSString? localizationName) { + final _ret = _objc_msgSend_331( + this.pointer, + _sel_pathForResource_ofType_inDirectory_forLocalization_, + name?.pointer ?? ffi.nullptr, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + localizationName?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// pathsForResourcesOfType:inDirectory:forLocalization: + objc.ObjCObjectBase pathsForResourcesOfType_inDirectory_forLocalization_( + objc.NSString? ext, + objc.NSString? subpath, + objc.NSString? localizationName) { + final _ret = _objc_msgSend_332( + this.pointer, + _sel_pathsForResourcesOfType_inDirectory_forLocalization_, + ext?.pointer ?? ffi.nullptr, + subpath?.pointer ?? ffi.nullptr, + localizationName?.pointer ?? ffi.nullptr); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// localizedStringForKey:value:table: + objc.NSString localizedStringForKey_value_table_( + objc.NSString key, objc.NSString? value, objc.NSString? tableName) { + final _ret = _objc_msgSend_333( + this.pointer, + _sel_localizedStringForKey_value_table_, + key.pointer, + value?.pointer ?? ffi.nullptr, + tableName?.pointer ?? ffi.nullptr); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// localizedAttributedStringForKey:value:table: + NSAttributedString localizedAttributedStringForKey_value_table_( + objc.NSString key, objc.NSString? value, objc.NSString? tableName) { + final _ret = _objc_msgSend_334( + this.pointer, + _sel_localizedAttributedStringForKey_value_table_, + key.pointer, + value?.pointer ?? ffi.nullptr, + tableName?.pointer ?? ffi.nullptr); + return NSAttributedString.castFromPointer(_ret, + retain: true, release: true); + } + + /// bundleIdentifier + objc.NSString? get bundleIdentifier { + final _ret = _objc_msgSend_72(this.pointer, _sel_bundleIdentifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// infoDictionary + objc.NSDictionary? get infoDictionary { + final _ret = _objc_msgSend_304(this.pointer, _sel_infoDictionary); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// localizedInfoDictionary + objc.NSDictionary? get localizedInfoDictionary { + final _ret = _objc_msgSend_304(this.pointer, _sel_localizedInfoDictionary); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// objectForInfoDictionaryKey: + objc.ObjCObjectBase? objectForInfoDictionaryKey_(objc.NSString key) { + final _ret = _objc_msgSend_277( + this.pointer, _sel_objectForInfoDictionaryKey_, key.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// classNamed: + objc.ObjCObjectBase? classNamed_(objc.NSString className) { + final _ret = + _objc_msgSend_277(this.pointer, _sel_classNamed_, className.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// principalClass + objc.ObjCObjectBase? get principalClass { + final _ret = _objc_msgSend_2(this.pointer, _sel_principalClass); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// preferredLocalizations + objc.ObjCObjectBase get preferredLocalizations { + final _ret = _objc_msgSend_34(this.pointer, _sel_preferredLocalizations); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// localizations + objc.ObjCObjectBase get localizations { + final _ret = _objc_msgSend_34(this.pointer, _sel_localizations); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// developmentLocalization + objc.NSString? get developmentLocalization { + final _ret = _objc_msgSend_72(this.pointer, _sel_developmentLocalization); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// preferredLocalizationsFromArray: + static objc.ObjCObjectBase preferredLocalizationsFromArray_( + objc.ObjCObjectBase localizationsArray) { + final _ret = _objc_msgSend_335(_class_NSBundle, + _sel_preferredLocalizationsFromArray_, localizationsArray.pointer); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// preferredLocalizationsFromArray:forPreferences: + static objc.ObjCObjectBase preferredLocalizationsFromArray_forPreferences_( + objc.ObjCObjectBase localizationsArray, + objc.ObjCObjectBase? preferencesArray) { + final _ret = _objc_msgSend_336( + _class_NSBundle, + _sel_preferredLocalizationsFromArray_forPreferences_, + localizationsArray.pointer, + preferencesArray?.pointer ?? ffi.nullptr); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// executableArchitectures + objc.ObjCObjectBase? get executableArchitectures { + final _ret = _objc_msgSend_2(this.pointer, _sel_executableArchitectures); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// init + NSBundle init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSBundle.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSBundle new1() { + final _ret = _objc_msgSend_34(_class_NSBundle, _sel_new); + return NSBundle.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSBundle allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSBundle, _sel_allocWithZone_, zone); + return NSBundle.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSBundle alloc() { + final _ret = _objc_msgSend_34(_class_NSBundle, _sel_alloc); + return NSBundle.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSBundle = objc.getClass("NSBundle"); +late final _sel_mainBundle = objc.registerName("mainBundle"); +final _objc_msgSend_315 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_bundleWithPath_ = objc.registerName("bundleWithPath:"); +late final _sel_initWithPath_ = objc.registerName("initWithPath:"); +late final _sel_bundleWithURL_ = objc.registerName("bundleWithURL:"); +final _objc_msgSend_316 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithURL_ = objc.registerName("initWithURL:"); +late final _sel_bundleForClass_ = objc.registerName("bundleForClass:"); +final _objc_msgSend_317 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_bundleWithIdentifier_ = + objc.registerName("bundleWithIdentifier:"); +final _objc_msgSend_318 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_allBundles = objc.registerName("allBundles"); +late final _sel_allFrameworks = objc.registerName("allFrameworks"); +late final _sel_load = objc.registerName("load"); +late final _sel_isLoaded = objc.registerName("isLoaded"); +late final _sel_unload = objc.registerName("unload"); +late final _sel_preflightAndReturnError_ = + objc.registerName("preflightAndReturnError:"); +final _objc_msgSend_319 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>)>(); +late final _sel_loadAndReturnError_ = objc.registerName("loadAndReturnError:"); +final _objc_msgSend_320 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_resourceURL = objc.registerName("resourceURL"); +late final _sel_URLForAuxiliaryExecutable_ = + objc.registerName("URLForAuxiliaryExecutable:"); +final _objc_msgSend_321 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_privateFrameworksURL = + objc.registerName("privateFrameworksURL"); +late final _sel_sharedFrameworksURL = objc.registerName("sharedFrameworksURL"); +late final _sel_sharedSupportURL = objc.registerName("sharedSupportURL"); +late final _sel_builtInPlugInsURL = objc.registerName("builtInPlugInsURL"); +late final _sel_appStoreReceiptURL = objc.registerName("appStoreReceiptURL"); +late final _sel_bundlePath = objc.registerName("bundlePath"); +late final _sel_resourcePath = objc.registerName("resourcePath"); +late final _sel_executablePath = objc.registerName("executablePath"); +late final _sel_pathForAuxiliaryExecutable_ = + objc.registerName("pathForAuxiliaryExecutable:"); +late final _sel_privateFrameworksPath = + objc.registerName("privateFrameworksPath"); +late final _sel_sharedFrameworksPath = + objc.registerName("sharedFrameworksPath"); +late final _sel_sharedSupportPath = objc.registerName("sharedSupportPath"); +late final _sel_builtInPlugInsPath = objc.registerName("builtInPlugInsPath"); +late final _sel_URLForResource_withExtension_subdirectory_inBundleWithURL_ = + objc.registerName( + "URLForResource:withExtension:subdirectory:inBundleWithURL:"); +final _objc_msgSend_322 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLsForResourcesWithExtension_subdirectory_inBundleWithURL_ = + objc.registerName( + "URLsForResourcesWithExtension:subdirectory:inBundleWithURL:"); +final _objc_msgSend_323 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLForResource_withExtension_ = + objc.registerName("URLForResource:withExtension:"); +final _objc_msgSend_324 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLForResource_withExtension_subdirectory_ = + objc.registerName("URLForResource:withExtension:subdirectory:"); +final _objc_msgSend_325 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLForResource_withExtension_subdirectory_localization_ = objc + .registerName("URLForResource:withExtension:subdirectory:localization:"); +final _objc_msgSend_326 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_URLsForResourcesWithExtension_subdirectory_ = + objc.registerName("URLsForResourcesWithExtension:subdirectory:"); +late final _sel_URLsForResourcesWithExtension_subdirectory_localization_ = objc + .registerName("URLsForResourcesWithExtension:subdirectory:localization:"); +final _objc_msgSend_327 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathForResource_ofType_inDirectory_ = + objc.registerName("pathForResource:ofType:inDirectory:"); +final _objc_msgSend_328 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathsForResourcesOfType_inDirectory_ = + objc.registerName("pathsForResourcesOfType:inDirectory:"); +final _objc_msgSend_329 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathForResource_ofType_ = + objc.registerName("pathForResource:ofType:"); +final _objc_msgSend_330 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathForResource_ofType_inDirectory_forLocalization_ = + objc.registerName("pathForResource:ofType:inDirectory:forLocalization:"); +final _objc_msgSend_331 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_pathsForResourcesOfType_inDirectory_forLocalization_ = + objc.registerName("pathsForResourcesOfType:inDirectory:forLocalization:"); +final _objc_msgSend_332 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_localizedStringForKey_value_table_ = + objc.registerName("localizedStringForKey:value:table:"); +final _objc_msgSend_333 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_localizedAttributedStringForKey_value_table_ = + objc.registerName("localizedAttributedStringForKey:value:table:"); +final _objc_msgSend_334 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_infoDictionary = objc.registerName("infoDictionary"); +late final _sel_localizedInfoDictionary = + objc.registerName("localizedInfoDictionary"); +late final _sel_objectForInfoDictionaryKey_ = + objc.registerName("objectForInfoDictionaryKey:"); +late final _sel_classNamed_ = objc.registerName("classNamed:"); +late final _sel_principalClass = objc.registerName("principalClass"); +late final _sel_preferredLocalizations = + objc.registerName("preferredLocalizations"); +late final _sel_localizations = objc.registerName("localizations"); +late final _sel_developmentLocalization = + objc.registerName("developmentLocalization"); +late final _sel_preferredLocalizationsFromArray_ = + objc.registerName("preferredLocalizationsFromArray:"); +final _objc_msgSend_335 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_preferredLocalizationsFromArray_forPreferences_ = + objc.registerName("preferredLocalizationsFromArray:forPreferences:"); +final _objc_msgSend_336 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_executableArchitectures = + objc.registerName("executableArchitectures"); +late final _sel_initWithAppearanceNamed_bundle_ = + objc.registerName("initWithAppearanceNamed:bundle:"); +final _objc_msgSend_337 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_bestMatchFromAppearancesWithNames_ = + objc.registerName("bestMatchFromAppearancesWithNames:"); +final _objc_msgSend_338 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_appearance = objc.registerName("appearance"); +final _objc_msgSend_339 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setAppearance_ = objc.registerName("setAppearance:"); +final _objc_msgSend_340 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_effectiveAppearance = objc.registerName("effectiveAppearance"); +late final _sel_sendAction_to_from_ = objc.registerName("sendAction:to:from:"); +final _objc_msgSend_341 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_targetForAction_ = objc.registerName("targetForAction:"); +final _objc_msgSend_342 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_targetForAction_to_from_ = + objc.registerName("targetForAction:to:from:"); +final _objc_msgSend_343 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_windowsMenu = objc.registerName("windowsMenu"); +late final _sel_setWindowsMenu_ = objc.registerName("setWindowsMenu:"); +late final _sel_arrangeInFront_ = objc.registerName("arrangeInFront:"); +late final _sel_removeWindowsItem_ = objc.registerName("removeWindowsItem:"); +late final _sel_addWindowsItem_title_filename_ = + objc.registerName("addWindowsItem:title:filename:"); +final _objc_msgSend_344 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_changeWindowsItem_title_filename_ = + objc.registerName("changeWindowsItem:title:filename:"); +late final _sel_updateWindowsItem_ = objc.registerName("updateWindowsItem:"); +late final _sel_miniaturizeAll_ = objc.registerName("miniaturizeAll:"); +late final _sel_isFullKeyboardAccessEnabled = + objc.registerName("isFullKeyboardAccessEnabled"); +late final _sel_servicesMenu = objc.registerName("servicesMenu"); +late final _sel_setServicesMenu_ = objc.registerName("setServicesMenu:"); +late final _sel_registerServicesMenuSendTypes_returnTypes_ = + objc.registerName("registerServicesMenuSendTypes:returnTypes:"); +final _objc_msgSend_345 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_servicesProvider = objc.registerName("servicesProvider"); +late final _sel_setServicesProvider_ = + objc.registerName("setServicesProvider:"); +late final _sel_orderFrontStandardAboutPanel_ = + objc.registerName("orderFrontStandardAboutPanel:"); +late final _sel_orderFrontStandardAboutPanelWithOptions_ = + objc.registerName("orderFrontStandardAboutPanelWithOptions:"); +final _objc_msgSend_346 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_disableRelaunchOnLogin = + objc.registerName("disableRelaunchOnLogin"); +late final _sel_enableRelaunchOnLogin = + objc.registerName("enableRelaunchOnLogin"); +late final _sel_registerForRemoteNotifications = + objc.registerName("registerForRemoteNotifications"); +late final _sel_unregisterForRemoteNotifications = + objc.registerName("unregisterForRemoteNotifications"); +late final _sel_isRegisteredForRemoteNotifications = + objc.registerName("isRegisteredForRemoteNotifications"); + +/// Soft deprecated. +/// Please use `NSApplication`'s `-registerForRemoteNotifications` along with `-requestAuthorizationWithOptions:` from the `UserNotifications.framework` to specify allowable notification types. +enum NSRemoteNotificationType { + NSRemoteNotificationTypeNone(0), + NSRemoteNotificationTypeBadge(1), + NSRemoteNotificationTypeSound(2), + NSRemoteNotificationTypeAlert(4); + + final int value; + const NSRemoteNotificationType(this.value); + + static NSRemoteNotificationType fromValue(int value) => switch (value) { + 0 => NSRemoteNotificationTypeNone, + 1 => NSRemoteNotificationTypeBadge, + 2 => NSRemoteNotificationTypeSound, + 4 => NSRemoteNotificationTypeAlert, + _ => throw ArgumentError( + "Unknown value for NSRemoteNotificationType: $value"), + }; +} + +late final _sel_registerForRemoteNotificationTypes_ = + objc.registerName("registerForRemoteNotificationTypes:"); +final _objc_msgSend_347 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.UnsignedLong)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, int)>(); +late final _sel_enabledRemoteNotificationTypes = + objc.registerName("enabledRemoteNotificationTypes"); +final _objc_msgSend_348 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_runModalForWindow_relativeToWindow_ = + objc.registerName("runModalForWindow:relativeToWindow:"); +final _objc_msgSend_349 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_beginModalSessionForWindow_relativeToWindow_ = + objc.registerName("beginModalSessionForWindow:relativeToWindow:"); +final _objc_msgSend_350 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer<_NSModalSession> Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer<_NSModalSession> Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_application_printFiles_ = + objc.registerName("application:printFiles:"); +final _objc_msgSend_351 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_beginSheet_modalForWindow_modalDelegate_didEndSelector_contextInfo_ = + objc.registerName( + "beginSheet:modalForWindow:modalDelegate:didEndSelector:contextInfo:"); +final _objc_msgSend_352 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_makeWindowsPerform_inOrder_ = + objc.registerName("makeWindowsPerform:inOrder:"); +final _objc_msgSend_353 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); + +/// NSApplicationDelegate +abstract final class NSApplicationDelegate { + /// Builds an object that implements the NSApplicationDelegate protocol. To implement + /// multiple protocols, use [addToBuilder] or [objc.ObjCProtocolBuilder] directly. + static objc.ObjCObjectBase implement( + {NSApplicationTerminateReply Function(NSApplication)? + applicationShouldTerminate_, + void Function(NSApplication, objc.ObjCObjectBase)? application_openURLs_, + bool Function(NSApplication, objc.NSString)? application_openFile_, + void Function(NSApplication, objc.ObjCObjectBase)? application_openFiles_, + bool Function(NSApplication, objc.NSString)? application_openTempFile_, + bool Function(NSApplication)? applicationShouldOpenUntitledFile_, + bool Function(NSApplication)? applicationOpenUntitledFile_, + bool Function(objc.ObjCObjectBase, objc.NSString)? + application_openFileWithoutUI_, + bool Function(NSApplication, objc.NSString)? application_printFile_, + NSApplicationPrintReply Function( + NSApplication, objc.ObjCObjectBase, objc.NSDictionary, bool)? + application_printFiles_withSettings_showPrintPanels_, + bool Function(NSApplication)? + applicationShouldTerminateAfterLastWindowClosed_, + bool Function(NSApplication, bool)? + applicationShouldHandleReopen_hasVisibleWindows_, + NSMenu? Function(NSApplication)? applicationDockMenu_, + objc.NSError Function(NSApplication, objc.NSError)? + application_willPresentError_, + void Function(NSApplication, objc.NSData)? + application_didRegisterForRemoteNotificationsWithDeviceToken_, + void Function(NSApplication, objc.NSError)? + application_didFailToRegisterForRemoteNotificationsWithError_, + void Function(NSApplication, objc.NSDictionary)? + application_didReceiveRemoteNotification_, + bool Function(NSApplication)? applicationSupportsSecureRestorableState_, + objc.ObjCObjectBase? Function(NSApplication, INIntent)? + application_handlerForIntent_, + void Function(NSApplication, objc.NSCoder)? + application_willEncodeRestorableState_, + void Function(NSApplication, objc.NSCoder)? + application_didDecodeRestorableState_, + bool Function(NSApplication, objc.NSString)? + application_willContinueUserActivityWithType_, + bool Function(NSApplication, NSUserActivity, ObjCBlock_ffiVoid_NSArray)? + application_continueUserActivity_restorationHandler_, + void Function(NSApplication, objc.NSString, objc.NSError)? + application_didFailToContinueUserActivityWithType_error_, + void Function(NSApplication, NSUserActivity)? + application_didUpdateUserActivity_, + void Function(NSApplication, CKShareMetadata)? + application_userDidAcceptCloudKitShareWithMetadata_, + bool Function(NSApplication, objc.NSString)? + application_delegateHandlesKey_, + bool Function(NSApplication)? + applicationShouldAutomaticallyLocalizeKeyEquivalents_, + void Function(objc.NSNotification)? applicationWillFinishLaunching_, + void Function(objc.NSNotification)? applicationDidFinishLaunching_, + void Function(objc.NSNotification)? applicationWillHide_, + void Function(objc.NSNotification)? applicationDidHide_, + void Function(objc.NSNotification)? applicationWillUnhide_, + void Function(objc.NSNotification)? applicationDidUnhide_, + void Function(objc.NSNotification)? applicationWillBecomeActive_, + void Function(objc.NSNotification)? applicationDidBecomeActive_, + void Function(objc.NSNotification)? applicationWillResignActive_, + void Function(objc.NSNotification)? applicationDidResignActive_, + void Function(objc.NSNotification)? applicationWillUpdate_, + void Function(objc.NSNotification)? applicationDidUpdate_, + void Function(objc.NSNotification)? applicationWillTerminate_, + void Function(objc.NSNotification)? applicationDidChangeScreenParameters_, + void Function(objc.NSNotification)? applicationDidChangeOcclusionState_, + void Function(objc.NSNotification)? applicationProtectedDataWillBecomeUnavailable_, + void Function(objc.NSNotification)? applicationProtectedDataDidBecomeAvailable_}) { + final builder = objc.ObjCProtocolBuilder(); + NSApplicationDelegate.applicationShouldTerminate_ + .implement(builder, applicationShouldTerminate_); + NSApplicationDelegate.application_openURLs_ + .implement(builder, application_openURLs_); + NSApplicationDelegate.application_openFile_ + .implement(builder, application_openFile_); + NSApplicationDelegate.application_openFiles_ + .implement(builder, application_openFiles_); + NSApplicationDelegate.application_openTempFile_ + .implement(builder, application_openTempFile_); + NSApplicationDelegate.applicationShouldOpenUntitledFile_ + .implement(builder, applicationShouldOpenUntitledFile_); + NSApplicationDelegate.applicationOpenUntitledFile_ + .implement(builder, applicationOpenUntitledFile_); + NSApplicationDelegate.application_openFileWithoutUI_ + .implement(builder, application_openFileWithoutUI_); + NSApplicationDelegate.application_printFile_ + .implement(builder, application_printFile_); + NSApplicationDelegate.application_printFiles_withSettings_showPrintPanels_ + .implement( + builder, application_printFiles_withSettings_showPrintPanels_); + NSApplicationDelegate.applicationShouldTerminateAfterLastWindowClosed_ + .implement(builder, applicationShouldTerminateAfterLastWindowClosed_); + NSApplicationDelegate.applicationShouldHandleReopen_hasVisibleWindows_ + .implement(builder, applicationShouldHandleReopen_hasVisibleWindows_); + NSApplicationDelegate.applicationDockMenu_ + .implement(builder, applicationDockMenu_); + NSApplicationDelegate.application_willPresentError_ + .implement(builder, application_willPresentError_); + NSApplicationDelegate + .application_didRegisterForRemoteNotificationsWithDeviceToken_ + .implement(builder, + application_didRegisterForRemoteNotificationsWithDeviceToken_); + NSApplicationDelegate + .application_didFailToRegisterForRemoteNotificationsWithError_ + .implement(builder, + application_didFailToRegisterForRemoteNotificationsWithError_); + NSApplicationDelegate.application_didReceiveRemoteNotification_ + .implement(builder, application_didReceiveRemoteNotification_); + NSApplicationDelegate.applicationSupportsSecureRestorableState_ + .implement(builder, applicationSupportsSecureRestorableState_); + NSApplicationDelegate.application_handlerForIntent_ + .implement(builder, application_handlerForIntent_); + NSApplicationDelegate.application_willEncodeRestorableState_ + .implement(builder, application_willEncodeRestorableState_); + NSApplicationDelegate.application_didDecodeRestorableState_ + .implement(builder, application_didDecodeRestorableState_); + NSApplicationDelegate.application_willContinueUserActivityWithType_ + .implement(builder, application_willContinueUserActivityWithType_); + NSApplicationDelegate.application_continueUserActivity_restorationHandler_ + .implement( + builder, application_continueUserActivity_restorationHandler_); + NSApplicationDelegate + .application_didFailToContinueUserActivityWithType_error_ + .implement( + builder, application_didFailToContinueUserActivityWithType_error_); + NSApplicationDelegate.application_didUpdateUserActivity_ + .implement(builder, application_didUpdateUserActivity_); + NSApplicationDelegate.application_userDidAcceptCloudKitShareWithMetadata_ + .implement( + builder, application_userDidAcceptCloudKitShareWithMetadata_); + NSApplicationDelegate.application_delegateHandlesKey_ + .implement(builder, application_delegateHandlesKey_); + NSApplicationDelegate.applicationShouldAutomaticallyLocalizeKeyEquivalents_ + .implement( + builder, applicationShouldAutomaticallyLocalizeKeyEquivalents_); + NSApplicationDelegate.applicationWillFinishLaunching_ + .implement(builder, applicationWillFinishLaunching_); + NSApplicationDelegate.applicationDidFinishLaunching_ + .implement(builder, applicationDidFinishLaunching_); + NSApplicationDelegate.applicationWillHide_ + .implement(builder, applicationWillHide_); + NSApplicationDelegate.applicationDidHide_ + .implement(builder, applicationDidHide_); + NSApplicationDelegate.applicationWillUnhide_ + .implement(builder, applicationWillUnhide_); + NSApplicationDelegate.applicationDidUnhide_ + .implement(builder, applicationDidUnhide_); + NSApplicationDelegate.applicationWillBecomeActive_ + .implement(builder, applicationWillBecomeActive_); + NSApplicationDelegate.applicationDidBecomeActive_ + .implement(builder, applicationDidBecomeActive_); + NSApplicationDelegate.applicationWillResignActive_ + .implement(builder, applicationWillResignActive_); + NSApplicationDelegate.applicationDidResignActive_ + .implement(builder, applicationDidResignActive_); + NSApplicationDelegate.applicationWillUpdate_ + .implement(builder, applicationWillUpdate_); + NSApplicationDelegate.applicationDidUpdate_ + .implement(builder, applicationDidUpdate_); + NSApplicationDelegate.applicationWillTerminate_ + .implement(builder, applicationWillTerminate_); + NSApplicationDelegate.applicationDidChangeScreenParameters_ + .implement(builder, applicationDidChangeScreenParameters_); + NSApplicationDelegate.applicationDidChangeOcclusionState_ + .implement(builder, applicationDidChangeOcclusionState_); + NSApplicationDelegate.applicationProtectedDataWillBecomeUnavailable_ + .implement(builder, applicationProtectedDataWillBecomeUnavailable_); + NSApplicationDelegate.applicationProtectedDataDidBecomeAvailable_ + .implement(builder, applicationProtectedDataDidBecomeAvailable_); + return builder.build(); + } + + /// Adds the implementation of the NSApplicationDelegate protocol to an existing + /// [objc.ObjCProtocolBuilder]. + static void addToBuilder(objc.ObjCProtocolBuilder builder, + {NSApplicationTerminateReply Function(NSApplication)? + applicationShouldTerminate_, + void Function(NSApplication, objc.ObjCObjectBase)? application_openURLs_, + bool Function(NSApplication, objc.NSString)? application_openFile_, + void Function(NSApplication, objc.ObjCObjectBase)? application_openFiles_, + bool Function(NSApplication, objc.NSString)? application_openTempFile_, + bool Function(NSApplication)? applicationShouldOpenUntitledFile_, + bool Function(NSApplication)? applicationOpenUntitledFile_, + bool Function(objc.ObjCObjectBase, objc.NSString)? + application_openFileWithoutUI_, + bool Function(NSApplication, objc.NSString)? application_printFile_, + NSApplicationPrintReply Function( + NSApplication, objc.ObjCObjectBase, objc.NSDictionary, bool)? + application_printFiles_withSettings_showPrintPanels_, + bool Function(NSApplication)? + applicationShouldTerminateAfterLastWindowClosed_, + bool Function(NSApplication, bool)? + applicationShouldHandleReopen_hasVisibleWindows_, + NSMenu? Function(NSApplication)? applicationDockMenu_, + objc.NSError Function(NSApplication, objc.NSError)? + application_willPresentError_, + void Function(NSApplication, objc.NSData)? + application_didRegisterForRemoteNotificationsWithDeviceToken_, + void Function(NSApplication, objc.NSError)? + application_didFailToRegisterForRemoteNotificationsWithError_, + void Function(NSApplication, objc.NSDictionary)? + application_didReceiveRemoteNotification_, + bool Function(NSApplication)? applicationSupportsSecureRestorableState_, + objc.ObjCObjectBase? Function(NSApplication, INIntent)? + application_handlerForIntent_, + void Function(NSApplication, objc.NSCoder)? + application_willEncodeRestorableState_, + void Function(NSApplication, objc.NSCoder)? + application_didDecodeRestorableState_, + bool Function(NSApplication, objc.NSString)? + application_willContinueUserActivityWithType_, + bool Function(NSApplication, NSUserActivity, ObjCBlock_ffiVoid_NSArray)? + application_continueUserActivity_restorationHandler_, + void Function(NSApplication, objc.NSString, objc.NSError)? + application_didFailToContinueUserActivityWithType_error_, + void Function(NSApplication, NSUserActivity)? + application_didUpdateUserActivity_, + void Function(NSApplication, CKShareMetadata)? + application_userDidAcceptCloudKitShareWithMetadata_, + bool Function(NSApplication, objc.NSString)? + application_delegateHandlesKey_, + bool Function(NSApplication)? + applicationShouldAutomaticallyLocalizeKeyEquivalents_, + void Function(objc.NSNotification)? applicationWillFinishLaunching_, + void Function(objc.NSNotification)? applicationDidFinishLaunching_, + void Function(objc.NSNotification)? applicationWillHide_, + void Function(objc.NSNotification)? applicationDidHide_, + void Function(objc.NSNotification)? applicationWillUnhide_, + void Function(objc.NSNotification)? applicationDidUnhide_, + void Function(objc.NSNotification)? applicationWillBecomeActive_, + void Function(objc.NSNotification)? applicationDidBecomeActive_, + void Function(objc.NSNotification)? applicationWillResignActive_, + void Function(objc.NSNotification)? applicationDidResignActive_, + void Function(objc.NSNotification)? applicationWillUpdate_, + void Function(objc.NSNotification)? applicationDidUpdate_, + void Function(objc.NSNotification)? applicationWillTerminate_, + void Function(objc.NSNotification)? applicationDidChangeScreenParameters_, + void Function(objc.NSNotification)? applicationDidChangeOcclusionState_, + void Function(objc.NSNotification)? applicationProtectedDataWillBecomeUnavailable_, + void Function(objc.NSNotification)? applicationProtectedDataDidBecomeAvailable_}) { + NSApplicationDelegate.applicationShouldTerminate_ + .implement(builder, applicationShouldTerminate_); + NSApplicationDelegate.application_openURLs_ + .implement(builder, application_openURLs_); + NSApplicationDelegate.application_openFile_ + .implement(builder, application_openFile_); + NSApplicationDelegate.application_openFiles_ + .implement(builder, application_openFiles_); + NSApplicationDelegate.application_openTempFile_ + .implement(builder, application_openTempFile_); + NSApplicationDelegate.applicationShouldOpenUntitledFile_ + .implement(builder, applicationShouldOpenUntitledFile_); + NSApplicationDelegate.applicationOpenUntitledFile_ + .implement(builder, applicationOpenUntitledFile_); + NSApplicationDelegate.application_openFileWithoutUI_ + .implement(builder, application_openFileWithoutUI_); + NSApplicationDelegate.application_printFile_ + .implement(builder, application_printFile_); + NSApplicationDelegate.application_printFiles_withSettings_showPrintPanels_ + .implement( + builder, application_printFiles_withSettings_showPrintPanels_); + NSApplicationDelegate.applicationShouldTerminateAfterLastWindowClosed_ + .implement(builder, applicationShouldTerminateAfterLastWindowClosed_); + NSApplicationDelegate.applicationShouldHandleReopen_hasVisibleWindows_ + .implement(builder, applicationShouldHandleReopen_hasVisibleWindows_); + NSApplicationDelegate.applicationDockMenu_ + .implement(builder, applicationDockMenu_); + NSApplicationDelegate.application_willPresentError_ + .implement(builder, application_willPresentError_); + NSApplicationDelegate + .application_didRegisterForRemoteNotificationsWithDeviceToken_ + .implement(builder, + application_didRegisterForRemoteNotificationsWithDeviceToken_); + NSApplicationDelegate + .application_didFailToRegisterForRemoteNotificationsWithError_ + .implement(builder, + application_didFailToRegisterForRemoteNotificationsWithError_); + NSApplicationDelegate.application_didReceiveRemoteNotification_ + .implement(builder, application_didReceiveRemoteNotification_); + NSApplicationDelegate.applicationSupportsSecureRestorableState_ + .implement(builder, applicationSupportsSecureRestorableState_); + NSApplicationDelegate.application_handlerForIntent_ + .implement(builder, application_handlerForIntent_); + NSApplicationDelegate.application_willEncodeRestorableState_ + .implement(builder, application_willEncodeRestorableState_); + NSApplicationDelegate.application_didDecodeRestorableState_ + .implement(builder, application_didDecodeRestorableState_); + NSApplicationDelegate.application_willContinueUserActivityWithType_ + .implement(builder, application_willContinueUserActivityWithType_); + NSApplicationDelegate.application_continueUserActivity_restorationHandler_ + .implement( + builder, application_continueUserActivity_restorationHandler_); + NSApplicationDelegate + .application_didFailToContinueUserActivityWithType_error_ + .implement( + builder, application_didFailToContinueUserActivityWithType_error_); + NSApplicationDelegate.application_didUpdateUserActivity_ + .implement(builder, application_didUpdateUserActivity_); + NSApplicationDelegate.application_userDidAcceptCloudKitShareWithMetadata_ + .implement( + builder, application_userDidAcceptCloudKitShareWithMetadata_); + NSApplicationDelegate.application_delegateHandlesKey_ + .implement(builder, application_delegateHandlesKey_); + NSApplicationDelegate.applicationShouldAutomaticallyLocalizeKeyEquivalents_ + .implement( + builder, applicationShouldAutomaticallyLocalizeKeyEquivalents_); + NSApplicationDelegate.applicationWillFinishLaunching_ + .implement(builder, applicationWillFinishLaunching_); + NSApplicationDelegate.applicationDidFinishLaunching_ + .implement(builder, applicationDidFinishLaunching_); + NSApplicationDelegate.applicationWillHide_ + .implement(builder, applicationWillHide_); + NSApplicationDelegate.applicationDidHide_ + .implement(builder, applicationDidHide_); + NSApplicationDelegate.applicationWillUnhide_ + .implement(builder, applicationWillUnhide_); + NSApplicationDelegate.applicationDidUnhide_ + .implement(builder, applicationDidUnhide_); + NSApplicationDelegate.applicationWillBecomeActive_ + .implement(builder, applicationWillBecomeActive_); + NSApplicationDelegate.applicationDidBecomeActive_ + .implement(builder, applicationDidBecomeActive_); + NSApplicationDelegate.applicationWillResignActive_ + .implement(builder, applicationWillResignActive_); + NSApplicationDelegate.applicationDidResignActive_ + .implement(builder, applicationDidResignActive_); + NSApplicationDelegate.applicationWillUpdate_ + .implement(builder, applicationWillUpdate_); + NSApplicationDelegate.applicationDidUpdate_ + .implement(builder, applicationDidUpdate_); + NSApplicationDelegate.applicationWillTerminate_ + .implement(builder, applicationWillTerminate_); + NSApplicationDelegate.applicationDidChangeScreenParameters_ + .implement(builder, applicationDidChangeScreenParameters_); + NSApplicationDelegate.applicationDidChangeOcclusionState_ + .implement(builder, applicationDidChangeOcclusionState_); + NSApplicationDelegate.applicationProtectedDataWillBecomeUnavailable_ + .implement(builder, applicationProtectedDataWillBecomeUnavailable_); + NSApplicationDelegate.applicationProtectedDataDidBecomeAvailable_ + .implement(builder, applicationProtectedDataDidBecomeAvailable_); + } + + /// Builds an object that implements the NSApplicationDelegate protocol. To implement + /// multiple protocols, use [addToBuilder] or [objc.ObjCProtocolBuilder] directly. All + /// methods that can be implemented as listeners will be. + static objc.ObjCObjectBase implementAsListener( + {NSApplicationTerminateReply Function(NSApplication)? + applicationShouldTerminate_, + void Function(NSApplication, objc.ObjCObjectBase)? application_openURLs_, + bool Function(NSApplication, objc.NSString)? application_openFile_, + void Function(NSApplication, objc.ObjCObjectBase)? application_openFiles_, + bool Function(NSApplication, objc.NSString)? application_openTempFile_, + bool Function(NSApplication)? applicationShouldOpenUntitledFile_, + bool Function(NSApplication)? applicationOpenUntitledFile_, + bool Function(objc.ObjCObjectBase, objc.NSString)? + application_openFileWithoutUI_, + bool Function(NSApplication, objc.NSString)? application_printFile_, + NSApplicationPrintReply Function( + NSApplication, objc.ObjCObjectBase, objc.NSDictionary, bool)? + application_printFiles_withSettings_showPrintPanels_, + bool Function(NSApplication)? + applicationShouldTerminateAfterLastWindowClosed_, + bool Function(NSApplication, bool)? + applicationShouldHandleReopen_hasVisibleWindows_, + NSMenu? Function(NSApplication)? applicationDockMenu_, + objc.NSError Function(NSApplication, objc.NSError)? + application_willPresentError_, + void Function(NSApplication, objc.NSData)? + application_didRegisterForRemoteNotificationsWithDeviceToken_, + void Function(NSApplication, objc.NSError)? + application_didFailToRegisterForRemoteNotificationsWithError_, + void Function(NSApplication, objc.NSDictionary)? + application_didReceiveRemoteNotification_, + bool Function(NSApplication)? applicationSupportsSecureRestorableState_, + objc.ObjCObjectBase? Function(NSApplication, INIntent)? + application_handlerForIntent_, + void Function(NSApplication, objc.NSCoder)? + application_willEncodeRestorableState_, + void Function(NSApplication, objc.NSCoder)? + application_didDecodeRestorableState_, + bool Function(NSApplication, objc.NSString)? + application_willContinueUserActivityWithType_, + bool Function(NSApplication, NSUserActivity, ObjCBlock_ffiVoid_NSArray)? + application_continueUserActivity_restorationHandler_, + void Function(NSApplication, objc.NSString, objc.NSError)? + application_didFailToContinueUserActivityWithType_error_, + void Function(NSApplication, NSUserActivity)? + application_didUpdateUserActivity_, + void Function(NSApplication, CKShareMetadata)? + application_userDidAcceptCloudKitShareWithMetadata_, + bool Function(NSApplication, objc.NSString)? + application_delegateHandlesKey_, + bool Function(NSApplication)? + applicationShouldAutomaticallyLocalizeKeyEquivalents_, + void Function(objc.NSNotification)? applicationWillFinishLaunching_, + void Function(objc.NSNotification)? applicationDidFinishLaunching_, + void Function(objc.NSNotification)? applicationWillHide_, + void Function(objc.NSNotification)? applicationDidHide_, + void Function(objc.NSNotification)? applicationWillUnhide_, + void Function(objc.NSNotification)? applicationDidUnhide_, + void Function(objc.NSNotification)? applicationWillBecomeActive_, + void Function(objc.NSNotification)? applicationDidBecomeActive_, + void Function(objc.NSNotification)? applicationWillResignActive_, + void Function(objc.NSNotification)? applicationDidResignActive_, + void Function(objc.NSNotification)? applicationWillUpdate_, + void Function(objc.NSNotification)? applicationDidUpdate_, + void Function(objc.NSNotification)? applicationWillTerminate_, + void Function(objc.NSNotification)? applicationDidChangeScreenParameters_, + void Function(objc.NSNotification)? applicationDidChangeOcclusionState_, + void Function(objc.NSNotification)? applicationProtectedDataWillBecomeUnavailable_, + void Function(objc.NSNotification)? applicationProtectedDataDidBecomeAvailable_}) { + final builder = objc.ObjCProtocolBuilder(); + NSApplicationDelegate.applicationShouldTerminate_ + .implement(builder, applicationShouldTerminate_); + NSApplicationDelegate.application_openURLs_ + .implementAsListener(builder, application_openURLs_); + NSApplicationDelegate.application_openFile_ + .implement(builder, application_openFile_); + NSApplicationDelegate.application_openFiles_ + .implementAsListener(builder, application_openFiles_); + NSApplicationDelegate.application_openTempFile_ + .implement(builder, application_openTempFile_); + NSApplicationDelegate.applicationShouldOpenUntitledFile_ + .implement(builder, applicationShouldOpenUntitledFile_); + NSApplicationDelegate.applicationOpenUntitledFile_ + .implement(builder, applicationOpenUntitledFile_); + NSApplicationDelegate.application_openFileWithoutUI_ + .implement(builder, application_openFileWithoutUI_); + NSApplicationDelegate.application_printFile_ + .implement(builder, application_printFile_); + NSApplicationDelegate.application_printFiles_withSettings_showPrintPanels_ + .implement( + builder, application_printFiles_withSettings_showPrintPanels_); + NSApplicationDelegate.applicationShouldTerminateAfterLastWindowClosed_ + .implement(builder, applicationShouldTerminateAfterLastWindowClosed_); + NSApplicationDelegate.applicationShouldHandleReopen_hasVisibleWindows_ + .implement(builder, applicationShouldHandleReopen_hasVisibleWindows_); + NSApplicationDelegate.applicationDockMenu_ + .implement(builder, applicationDockMenu_); + NSApplicationDelegate.application_willPresentError_ + .implement(builder, application_willPresentError_); + NSApplicationDelegate + .application_didRegisterForRemoteNotificationsWithDeviceToken_ + .implementAsListener(builder, + application_didRegisterForRemoteNotificationsWithDeviceToken_); + NSApplicationDelegate + .application_didFailToRegisterForRemoteNotificationsWithError_ + .implementAsListener(builder, + application_didFailToRegisterForRemoteNotificationsWithError_); + NSApplicationDelegate.application_didReceiveRemoteNotification_ + .implementAsListener( + builder, application_didReceiveRemoteNotification_); + NSApplicationDelegate.applicationSupportsSecureRestorableState_ + .implement(builder, applicationSupportsSecureRestorableState_); + NSApplicationDelegate.application_handlerForIntent_ + .implement(builder, application_handlerForIntent_); + NSApplicationDelegate.application_willEncodeRestorableState_ + .implementAsListener(builder, application_willEncodeRestorableState_); + NSApplicationDelegate.application_didDecodeRestorableState_ + .implementAsListener(builder, application_didDecodeRestorableState_); + NSApplicationDelegate.application_willContinueUserActivityWithType_ + .implement(builder, application_willContinueUserActivityWithType_); + NSApplicationDelegate.application_continueUserActivity_restorationHandler_ + .implement( + builder, application_continueUserActivity_restorationHandler_); + NSApplicationDelegate + .application_didFailToContinueUserActivityWithType_error_ + .implementAsListener( + builder, application_didFailToContinueUserActivityWithType_error_); + NSApplicationDelegate.application_didUpdateUserActivity_ + .implementAsListener(builder, application_didUpdateUserActivity_); + NSApplicationDelegate.application_userDidAcceptCloudKitShareWithMetadata_ + .implementAsListener( + builder, application_userDidAcceptCloudKitShareWithMetadata_); + NSApplicationDelegate.application_delegateHandlesKey_ + .implement(builder, application_delegateHandlesKey_); + NSApplicationDelegate.applicationShouldAutomaticallyLocalizeKeyEquivalents_ + .implement( + builder, applicationShouldAutomaticallyLocalizeKeyEquivalents_); + NSApplicationDelegate.applicationWillFinishLaunching_ + .implementAsListener(builder, applicationWillFinishLaunching_); + NSApplicationDelegate.applicationDidFinishLaunching_ + .implementAsListener(builder, applicationDidFinishLaunching_); + NSApplicationDelegate.applicationWillHide_ + .implementAsListener(builder, applicationWillHide_); + NSApplicationDelegate.applicationDidHide_ + .implementAsListener(builder, applicationDidHide_); + NSApplicationDelegate.applicationWillUnhide_ + .implementAsListener(builder, applicationWillUnhide_); + NSApplicationDelegate.applicationDidUnhide_ + .implementAsListener(builder, applicationDidUnhide_); + NSApplicationDelegate.applicationWillBecomeActive_ + .implementAsListener(builder, applicationWillBecomeActive_); + NSApplicationDelegate.applicationDidBecomeActive_ + .implementAsListener(builder, applicationDidBecomeActive_); + NSApplicationDelegate.applicationWillResignActive_ + .implementAsListener(builder, applicationWillResignActive_); + NSApplicationDelegate.applicationDidResignActive_ + .implementAsListener(builder, applicationDidResignActive_); + NSApplicationDelegate.applicationWillUpdate_ + .implementAsListener(builder, applicationWillUpdate_); + NSApplicationDelegate.applicationDidUpdate_ + .implementAsListener(builder, applicationDidUpdate_); + NSApplicationDelegate.applicationWillTerminate_ + .implementAsListener(builder, applicationWillTerminate_); + NSApplicationDelegate.applicationDidChangeScreenParameters_ + .implementAsListener(builder, applicationDidChangeScreenParameters_); + NSApplicationDelegate.applicationDidChangeOcclusionState_ + .implementAsListener(builder, applicationDidChangeOcclusionState_); + NSApplicationDelegate.applicationProtectedDataWillBecomeUnavailable_ + .implementAsListener( + builder, applicationProtectedDataWillBecomeUnavailable_); + NSApplicationDelegate.applicationProtectedDataDidBecomeAvailable_ + .implementAsListener( + builder, applicationProtectedDataDidBecomeAvailable_); + return builder.build(); + } + + /// Adds the implementation of the NSApplicationDelegate protocol to an existing + /// [objc.ObjCProtocolBuilder]. All methods that can be implemented as listeners will + /// be. + static void addToBuilderAsListener(objc.ObjCProtocolBuilder builder, + {NSApplicationTerminateReply Function(NSApplication)? + applicationShouldTerminate_, + void Function(NSApplication, objc.ObjCObjectBase)? application_openURLs_, + bool Function(NSApplication, objc.NSString)? application_openFile_, + void Function(NSApplication, objc.ObjCObjectBase)? application_openFiles_, + bool Function(NSApplication, objc.NSString)? application_openTempFile_, + bool Function(NSApplication)? applicationShouldOpenUntitledFile_, + bool Function(NSApplication)? applicationOpenUntitledFile_, + bool Function(objc.ObjCObjectBase, objc.NSString)? + application_openFileWithoutUI_, + bool Function(NSApplication, objc.NSString)? application_printFile_, + NSApplicationPrintReply Function( + NSApplication, objc.ObjCObjectBase, objc.NSDictionary, bool)? + application_printFiles_withSettings_showPrintPanels_, + bool Function(NSApplication)? + applicationShouldTerminateAfterLastWindowClosed_, + bool Function(NSApplication, bool)? + applicationShouldHandleReopen_hasVisibleWindows_, + NSMenu? Function(NSApplication)? applicationDockMenu_, + objc.NSError Function(NSApplication, objc.NSError)? + application_willPresentError_, + void Function(NSApplication, objc.NSData)? + application_didRegisterForRemoteNotificationsWithDeviceToken_, + void Function(NSApplication, objc.NSError)? + application_didFailToRegisterForRemoteNotificationsWithError_, + void Function(NSApplication, objc.NSDictionary)? + application_didReceiveRemoteNotification_, + bool Function(NSApplication)? applicationSupportsSecureRestorableState_, + objc.ObjCObjectBase? Function(NSApplication, INIntent)? + application_handlerForIntent_, + void Function(NSApplication, objc.NSCoder)? + application_willEncodeRestorableState_, + void Function(NSApplication, objc.NSCoder)? + application_didDecodeRestorableState_, + bool Function(NSApplication, objc.NSString)? + application_willContinueUserActivityWithType_, + bool Function(NSApplication, NSUserActivity, ObjCBlock_ffiVoid_NSArray)? + application_continueUserActivity_restorationHandler_, + void Function(NSApplication, objc.NSString, objc.NSError)? + application_didFailToContinueUserActivityWithType_error_, + void Function(NSApplication, NSUserActivity)? + application_didUpdateUserActivity_, + void Function(NSApplication, CKShareMetadata)? + application_userDidAcceptCloudKitShareWithMetadata_, + bool Function(NSApplication, objc.NSString)? + application_delegateHandlesKey_, + bool Function(NSApplication)? + applicationShouldAutomaticallyLocalizeKeyEquivalents_, + void Function(objc.NSNotification)? applicationWillFinishLaunching_, + void Function(objc.NSNotification)? applicationDidFinishLaunching_, + void Function(objc.NSNotification)? applicationWillHide_, + void Function(objc.NSNotification)? applicationDidHide_, + void Function(objc.NSNotification)? applicationWillUnhide_, + void Function(objc.NSNotification)? applicationDidUnhide_, + void Function(objc.NSNotification)? applicationWillBecomeActive_, + void Function(objc.NSNotification)? applicationDidBecomeActive_, + void Function(objc.NSNotification)? applicationWillResignActive_, + void Function(objc.NSNotification)? applicationDidResignActive_, + void Function(objc.NSNotification)? applicationWillUpdate_, + void Function(objc.NSNotification)? applicationDidUpdate_, + void Function(objc.NSNotification)? applicationWillTerminate_, + void Function(objc.NSNotification)? applicationDidChangeScreenParameters_, + void Function(objc.NSNotification)? applicationDidChangeOcclusionState_, + void Function(objc.NSNotification)? applicationProtectedDataWillBecomeUnavailable_, + void Function(objc.NSNotification)? applicationProtectedDataDidBecomeAvailable_}) { + NSApplicationDelegate.applicationShouldTerminate_ + .implement(builder, applicationShouldTerminate_); + NSApplicationDelegate.application_openURLs_ + .implementAsListener(builder, application_openURLs_); + NSApplicationDelegate.application_openFile_ + .implement(builder, application_openFile_); + NSApplicationDelegate.application_openFiles_ + .implementAsListener(builder, application_openFiles_); + NSApplicationDelegate.application_openTempFile_ + .implement(builder, application_openTempFile_); + NSApplicationDelegate.applicationShouldOpenUntitledFile_ + .implement(builder, applicationShouldOpenUntitledFile_); + NSApplicationDelegate.applicationOpenUntitledFile_ + .implement(builder, applicationOpenUntitledFile_); + NSApplicationDelegate.application_openFileWithoutUI_ + .implement(builder, application_openFileWithoutUI_); + NSApplicationDelegate.application_printFile_ + .implement(builder, application_printFile_); + NSApplicationDelegate.application_printFiles_withSettings_showPrintPanels_ + .implement( + builder, application_printFiles_withSettings_showPrintPanels_); + NSApplicationDelegate.applicationShouldTerminateAfterLastWindowClosed_ + .implement(builder, applicationShouldTerminateAfterLastWindowClosed_); + NSApplicationDelegate.applicationShouldHandleReopen_hasVisibleWindows_ + .implement(builder, applicationShouldHandleReopen_hasVisibleWindows_); + NSApplicationDelegate.applicationDockMenu_ + .implement(builder, applicationDockMenu_); + NSApplicationDelegate.application_willPresentError_ + .implement(builder, application_willPresentError_); + NSApplicationDelegate + .application_didRegisterForRemoteNotificationsWithDeviceToken_ + .implementAsListener(builder, + application_didRegisterForRemoteNotificationsWithDeviceToken_); + NSApplicationDelegate + .application_didFailToRegisterForRemoteNotificationsWithError_ + .implementAsListener(builder, + application_didFailToRegisterForRemoteNotificationsWithError_); + NSApplicationDelegate.application_didReceiveRemoteNotification_ + .implementAsListener( + builder, application_didReceiveRemoteNotification_); + NSApplicationDelegate.applicationSupportsSecureRestorableState_ + .implement(builder, applicationSupportsSecureRestorableState_); + NSApplicationDelegate.application_handlerForIntent_ + .implement(builder, application_handlerForIntent_); + NSApplicationDelegate.application_willEncodeRestorableState_ + .implementAsListener(builder, application_willEncodeRestorableState_); + NSApplicationDelegate.application_didDecodeRestorableState_ + .implementAsListener(builder, application_didDecodeRestorableState_); + NSApplicationDelegate.application_willContinueUserActivityWithType_ + .implement(builder, application_willContinueUserActivityWithType_); + NSApplicationDelegate.application_continueUserActivity_restorationHandler_ + .implement( + builder, application_continueUserActivity_restorationHandler_); + NSApplicationDelegate + .application_didFailToContinueUserActivityWithType_error_ + .implementAsListener( + builder, application_didFailToContinueUserActivityWithType_error_); + NSApplicationDelegate.application_didUpdateUserActivity_ + .implementAsListener(builder, application_didUpdateUserActivity_); + NSApplicationDelegate.application_userDidAcceptCloudKitShareWithMetadata_ + .implementAsListener( + builder, application_userDidAcceptCloudKitShareWithMetadata_); + NSApplicationDelegate.application_delegateHandlesKey_ + .implement(builder, application_delegateHandlesKey_); + NSApplicationDelegate.applicationShouldAutomaticallyLocalizeKeyEquivalents_ + .implement( + builder, applicationShouldAutomaticallyLocalizeKeyEquivalents_); + NSApplicationDelegate.applicationWillFinishLaunching_ + .implementAsListener(builder, applicationWillFinishLaunching_); + NSApplicationDelegate.applicationDidFinishLaunching_ + .implementAsListener(builder, applicationDidFinishLaunching_); + NSApplicationDelegate.applicationWillHide_ + .implementAsListener(builder, applicationWillHide_); + NSApplicationDelegate.applicationDidHide_ + .implementAsListener(builder, applicationDidHide_); + NSApplicationDelegate.applicationWillUnhide_ + .implementAsListener(builder, applicationWillUnhide_); + NSApplicationDelegate.applicationDidUnhide_ + .implementAsListener(builder, applicationDidUnhide_); + NSApplicationDelegate.applicationWillBecomeActive_ + .implementAsListener(builder, applicationWillBecomeActive_); + NSApplicationDelegate.applicationDidBecomeActive_ + .implementAsListener(builder, applicationDidBecomeActive_); + NSApplicationDelegate.applicationWillResignActive_ + .implementAsListener(builder, applicationWillResignActive_); + NSApplicationDelegate.applicationDidResignActive_ + .implementAsListener(builder, applicationDidResignActive_); + NSApplicationDelegate.applicationWillUpdate_ + .implementAsListener(builder, applicationWillUpdate_); + NSApplicationDelegate.applicationDidUpdate_ + .implementAsListener(builder, applicationDidUpdate_); + NSApplicationDelegate.applicationWillTerminate_ + .implementAsListener(builder, applicationWillTerminate_); + NSApplicationDelegate.applicationDidChangeScreenParameters_ + .implementAsListener(builder, applicationDidChangeScreenParameters_); + NSApplicationDelegate.applicationDidChangeOcclusionState_ + .implementAsListener(builder, applicationDidChangeOcclusionState_); + NSApplicationDelegate.applicationProtectedDataWillBecomeUnavailable_ + .implementAsListener( + builder, applicationProtectedDataWillBecomeUnavailable_); + NSApplicationDelegate.applicationProtectedDataDidBecomeAvailable_ + .implementAsListener( + builder, applicationProtectedDataDidBecomeAvailable_); + } + + /// Allowable return values are: + /// @c NSTerminateNow - it is ok to proceed with termination + /// @c NSTerminateCancel - the application should not be terminated + /// @c NSTerminateLater - it may be ok to proceed with termination later. The application must call `-replyToApplicationShouldTerminate:` with @c YES or @c NO once the answer is known + /// @note This return value is for delegates who need to provide document modal alerts (sheets) in order to decide whether to quit. + static final applicationShouldTerminate_ = objc.ObjCProtocolMethod< + NSApplicationTerminateReply Function(NSApplication)>( + _sel_applicationShouldTerminate_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationShouldTerminate_, + isRequired: false, + isInstanceMethod: true, + ), + (NSApplicationTerminateReply Function(NSApplication) func) => + ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication + .fromFunction( + (ffi.Pointer _, NSApplication arg1) => func(arg1)), + ); + + /// This will be called for any URLs your application is asked to open. This includes URL types (CFBundleURLTypes) defined in your Info.plist, and Document types (@c CFBundleDocumentTypes) that have no associated @c NSDocument class. Document URLs that have an associated @c NSDocument class will be opened through @c NSDocumentController. If this is implemented, `-application:openFiles:` and `-application:openFile:` will not be called. + static final application_openURLs_ = objc.ObjCProtocolListenableMethod< + void Function(NSApplication, objc.ObjCObjectBase)>( + _sel_application_openURLs_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_openURLs_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, objc.ObjCObjectBase) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject.fromFunction( + (ffi.Pointer _, NSApplication arg1, + objc.ObjCObjectBase arg2) => + func(arg1, arg2)), + (void Function(NSApplication, objc.ObjCObjectBase) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject.listener( + (ffi.Pointer _, NSApplication arg1, + objc.ObjCObjectBase arg2) => + func(arg1, arg2)), + ); + + /// application:openFile: + static final application_openFile_ = + objc.ObjCProtocolMethod( + _sel_application_openFile_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_openFile_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication, objc.NSString) func) => + ObjCBlock_bool_ffiVoid_NSApplication_NSString.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSString arg2) => + func(arg1, arg2)), + ); + + /// application:openFiles: + static final application_openFiles_ = objc.ObjCProtocolListenableMethod< + void Function(NSApplication, objc.ObjCObjectBase)>( + _sel_application_openFiles_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_openFiles_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, objc.ObjCObjectBase) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject.fromFunction( + (ffi.Pointer _, NSApplication arg1, + objc.ObjCObjectBase arg2) => + func(arg1, arg2)), + (void Function(NSApplication, objc.ObjCObjectBase) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject.listener( + (ffi.Pointer _, NSApplication arg1, + objc.ObjCObjectBase arg2) => + func(arg1, arg2)), + ); + + /// application:openTempFile: + static final application_openTempFile_ = + objc.ObjCProtocolMethod( + _sel_application_openTempFile_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_openTempFile_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication, objc.NSString) func) => + ObjCBlock_bool_ffiVoid_NSApplication_NSString.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSString arg2) => + func(arg1, arg2)), + ); + + /// applicationShouldOpenUntitledFile: + static final applicationShouldOpenUntitledFile_ = + objc.ObjCProtocolMethod( + _sel_applicationShouldOpenUntitledFile_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationShouldOpenUntitledFile_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication) func) => + ObjCBlock_bool_ffiVoid_NSApplication.fromFunction( + (ffi.Pointer _, NSApplication arg1) => func(arg1)), + ); + + /// applicationOpenUntitledFile: + static final applicationOpenUntitledFile_ = + objc.ObjCProtocolMethod( + _sel_applicationOpenUntitledFile_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationOpenUntitledFile_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication) func) => + ObjCBlock_bool_ffiVoid_NSApplication.fromFunction( + (ffi.Pointer _, NSApplication arg1) => func(arg1)), + ); + + /// application:openFileWithoutUI: + static final application_openFileWithoutUI_ = objc.ObjCProtocolMethod< + bool Function(objc.ObjCObjectBase, objc.NSString)>( + _sel_application_openFileWithoutUI_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_openFileWithoutUI_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(objc.ObjCObjectBase, objc.NSString) func) => + ObjCBlock_bool_ffiVoid_objcObjCObject_NSString.fromFunction( + (ffi.Pointer _, objc.ObjCObjectBase arg1, + objc.NSString arg2) => + func(arg1, arg2)), + ); + + /// application:printFile: + static final application_printFile_ = + objc.ObjCProtocolMethod( + _sel_application_printFile_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_printFile_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication, objc.NSString) func) => + ObjCBlock_bool_ffiVoid_NSApplication_NSString.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSString arg2) => + func(arg1, arg2)), + ); + + /// application:printFiles:withSettings:showPrintPanels: + static final application_printFiles_withSettings_showPrintPanels_ = + objc.ObjCProtocolMethod< + NSApplicationPrintReply Function( + NSApplication, objc.ObjCObjectBase, objc.NSDictionary, bool)>( + _sel_application_printFiles_withSettings_showPrintPanels_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_printFiles_withSettings_showPrintPanels_, + isRequired: false, + isInstanceMethod: true, + ), + (NSApplicationPrintReply Function( + NSApplication, objc.ObjCObjectBase, objc.NSDictionary, bool) + func) => + ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool + .fromFunction((ffi.Pointer _, + NSApplication arg1, + objc.ObjCObjectBase arg2, + objc.NSDictionary arg3, + bool arg4) => + func(arg1, arg2, arg3, arg4)), + ); + + /// applicationShouldTerminateAfterLastWindowClosed: + static final applicationShouldTerminateAfterLastWindowClosed_ = + objc.ObjCProtocolMethod( + _sel_applicationShouldTerminateAfterLastWindowClosed_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationShouldTerminateAfterLastWindowClosed_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication) func) => + ObjCBlock_bool_ffiVoid_NSApplication.fromFunction( + (ffi.Pointer _, NSApplication arg1) => func(arg1)), + ); + + /// applicationShouldHandleReopen:hasVisibleWindows: + static final applicationShouldHandleReopen_hasVisibleWindows_ = + objc.ObjCProtocolMethod( + _sel_applicationShouldHandleReopen_hasVisibleWindows_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationShouldHandleReopen_hasVisibleWindows_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication, bool) func) => + ObjCBlock_bool_ffiVoid_NSApplication_bool.fromFunction( + (ffi.Pointer _, NSApplication arg1, bool arg2) => + func(arg1, arg2)), + ); + + /// applicationDockMenu: + static final applicationDockMenu_ = + objc.ObjCProtocolMethod( + _sel_applicationDockMenu_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationDockMenu_, + isRequired: false, + isInstanceMethod: true, + ), + (NSMenu? Function(NSApplication) func) => + ObjCBlock_NSMenu_ffiVoid_NSApplication.fromFunction( + (ffi.Pointer _, NSApplication arg1) => func(arg1)), + ); + + /// application:willPresentError: + static final application_willPresentError_ = objc.ObjCProtocolMethod< + objc.NSError Function(NSApplication, objc.NSError)>( + _sel_application_willPresentError_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_willPresentError_, + isRequired: false, + isInstanceMethod: true, + ), + (objc.NSError Function(NSApplication, objc.NSError) func) => + ObjCBlock_NSError_ffiVoid_NSApplication_NSError.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSError arg2) => + func(arg1, arg2)), + ); + + /// application:didRegisterForRemoteNotificationsWithDeviceToken: + static final application_didRegisterForRemoteNotificationsWithDeviceToken_ = + objc.ObjCProtocolListenableMethod< + void Function(NSApplication, objc.NSData)>( + _sel_application_didRegisterForRemoteNotificationsWithDeviceToken_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_didRegisterForRemoteNotificationsWithDeviceToken_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, objc.NSData) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSData arg2) => + func(arg1, arg2)), + (void Function(NSApplication, objc.NSData) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData.listener( + (ffi.Pointer _, NSApplication arg1, objc.NSData arg2) => + func(arg1, arg2)), + ); + + /// application:didFailToRegisterForRemoteNotificationsWithError: + static final application_didFailToRegisterForRemoteNotificationsWithError_ = + objc.ObjCProtocolListenableMethod< + void Function(NSApplication, objc.NSError)>( + _sel_application_didFailToRegisterForRemoteNotificationsWithError_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_didFailToRegisterForRemoteNotificationsWithError_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, objc.NSError) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSError arg2) => + func(arg1, arg2)), + (void Function(NSApplication, objc.NSError) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError.listener( + (ffi.Pointer _, NSApplication arg1, objc.NSError arg2) => + func(arg1, arg2)), + ); + + /// application:didReceiveRemoteNotification: + static final application_didReceiveRemoteNotification_ = + objc.ObjCProtocolListenableMethod< + void Function(NSApplication, objc.NSDictionary)>( + _sel_application_didReceiveRemoteNotification_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_didReceiveRemoteNotification_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, objc.NSDictionary) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary.fromFunction( + (ffi.Pointer _, NSApplication arg1, + objc.NSDictionary arg2) => + func(arg1, arg2)), + (void Function(NSApplication, objc.NSDictionary) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary.listener( + (ffi.Pointer _, NSApplication arg1, + objc.NSDictionary arg2) => + func(arg1, arg2)), + ); + + /// Method to opt-in to secure restorable state. + /// + /// When this returns @c YES: + /// NSCoders that are passed into the various @c NSWindowRestoration methods will @c requiresSecureCoding and have a @c decodingFailurePolicy of @c NSDecodingFailurePolicySetErrorAndReturn. + /// Any @c restorationClass set on a window must explicitly conform to @c NSWindowRestoration. + /// + /// This method will be called prior to any state encoding or restoration. + static final applicationSupportsSecureRestorableState_ = + objc.ObjCProtocolMethod( + _sel_applicationSupportsSecureRestorableState_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationSupportsSecureRestorableState_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication) func) => + ObjCBlock_bool_ffiVoid_NSApplication.fromFunction( + (ffi.Pointer _, NSApplication arg1) => func(arg1)), + ); + + /// @return The object capable of handling the specified intent. + static final application_handlerForIntent_ = objc.ObjCProtocolMethod< + objc.ObjCObjectBase? Function(NSApplication, INIntent)>( + _sel_application_handlerForIntent_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_handlerForIntent_, + isRequired: false, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase? Function(NSApplication, INIntent) func) => + ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent.fromFunction( + (ffi.Pointer _, NSApplication arg1, INIntent arg2) => + func(arg1, arg2)), + ); + + /// Method called by `-[NSApplication encodeRestorableStateWithCoder:]` to give the delegate a chance to encode any additional state into the @c NSCoder. If the restorable state managed by the delegate changes, you must call `-[NSApplication invalidateRestorableState]` so that it will be re-encoded. See the header `NSWindowRestoration.h` for more information. + static final application_willEncodeRestorableState_ = objc + .ObjCProtocolListenableMethod( + _sel_application_willEncodeRestorableState_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_willEncodeRestorableState_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, objc.NSCoder) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSCoder arg2) => + func(arg1, arg2)), + (void Function(NSApplication, objc.NSCoder) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder.listener( + (ffi.Pointer _, NSApplication arg1, objc.NSCoder arg2) => + func(arg1, arg2)), + ); + + /// Method called by `-[NSApplication restoreStateWithCoder:]` to give the delegate a chance to restore its own state, which it may decode from the @c NSCoder. See the header `NSWindowRestoration.h` for more information. + static final application_didDecodeRestorableState_ = objc + .ObjCProtocolListenableMethod( + _sel_application_didDecodeRestorableState_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_didDecodeRestorableState_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, objc.NSCoder) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSCoder arg2) => + func(arg1, arg2)), + (void Function(NSApplication, objc.NSCoder) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder.listener( + (ffi.Pointer _, NSApplication arg1, objc.NSCoder arg2) => + func(arg1, arg2)), + ); + + /// This will be called on the main thread as soon as the user indicates they want to continue an activity in your application. The @c NSUserActivity object may not be available instantly, so use this as an opportunity to show the user that an activity will be continued shortly. Return @c YES to indicate that you are doing so. Return @c NO (or leave it unimplemented) and AppKit/UIKit will put up a default UI. + /// + /// For each `-application:willContinueUserActivityWithType:` invocation, you are guaranteed to get exactly one invocation of `-application:continueUserActivity:restorationHandler:` on success, or `-application:didFailToContinueUserActivityWithType:error:` if an error was encountered. + static final application_willContinueUserActivityWithType_ = + objc.ObjCProtocolMethod( + _sel_application_willContinueUserActivityWithType_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_willContinueUserActivityWithType_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication, objc.NSString) func) => + ObjCBlock_bool_ffiVoid_NSApplication_NSString.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSString arg2) => + func(arg1, arg2)), + ); + + /// This will be called on the main thread after the @c NSUserActivity object is available. Use the data you stored in the NSUserActivity object to re-create what the user was doing. + /// + /// @return @c YES to indicate that the activity was handled. Return @c NO (or leave it unimplemented) and AppKit will attempt to continue the user activity. + /// + /// You should create/fetch any restorable objects associated with the user activity, and pass them to the restorationHandler. They will then get the above `-restoreUserActivityState:` method invoked with the user activity. Invoking the @c restorationHandler is optional. It may be copied and invoked later, but must be invoked on the main thread. + /// + /// If this user activity was created automatically by having @c NSUbiquitousDocumentUserActivityType in a @c CFBundleDocumentTypes entry, AppKit can automatically restore the NSUserActivity on OS X if NO is returned, or this method is unimplemented. It will do so by creating a document of the appropriate type using the URL stored in the userInfo under the @c NSUserActivityDocumentURLKey. The document will have `-restoreUserActivity:` called on it. + static final application_continueUserActivity_restorationHandler_ = + objc.ObjCProtocolMethod< + bool Function( + NSApplication, NSUserActivity, ObjCBlock_ffiVoid_NSArray)>( + _sel_application_continueUserActivity_restorationHandler_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_continueUserActivity_restorationHandler_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication, NSUserActivity, ObjCBlock_ffiVoid_NSArray) + func) => + ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray + .fromFunction((ffi.Pointer _, NSApplication arg1, + NSUserActivity arg2, ObjCBlock_ffiVoid_NSArray arg3) => + func(arg1, arg2, arg3)), + ); + + /// There are instances where continuing a @c NSUserActivity may fail. This will get called on the main thread if it does so. If it is unimplemented, AppKit will present the error. + static final application_didFailToContinueUserActivityWithType_error_ = + objc.ObjCProtocolListenableMethod< + void Function(NSApplication, objc.NSString, objc.NSError)>( + _sel_application_didFailToContinueUserActivityWithType_error_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_didFailToContinueUserActivityWithType_error_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, objc.NSString, objc.NSError) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSString arg2, + objc.NSError arg3) => + func(arg1, arg2, arg3)), + (void Function(NSApplication, objc.NSString, objc.NSError) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError.listener( + (ffi.Pointer _, NSApplication arg1, objc.NSString arg2, + objc.NSError arg3) => + func(arg1, arg2, arg3)), + ); + + /// This will be called on the main thread when a user activity managed by AppKit/UIKit has been updated. You should use this as a last chance to add additional data to the @c userActivity. + static final application_didUpdateUserActivity_ = + objc.ObjCProtocolListenableMethod< + void Function(NSApplication, NSUserActivity)>( + _sel_application_didUpdateUserActivity_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_didUpdateUserActivity_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, NSUserActivity) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity.fromFunction( + (ffi.Pointer _, NSApplication arg1, + NSUserActivity arg2) => + func(arg1, arg2)), + (void Function(NSApplication, NSUserActivity) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity.listener( + (ffi.Pointer _, NSApplication arg1, + NSUserActivity arg2) => + func(arg1, arg2)), + ); + + /// This will be called on the main thread after the user indicates they want to accept a CloudKit sharing invitation in your application. + /// + /// You should use the @c CKShareMetadata object's @c shareURL and containerIdentifier to schedule a @c CKAcceptSharesOperation, then start using the resulting @c CKShare and its associated record(s), which will appear in the @c CKContainer's shared database in a zone matching that of the record's owner. + static final application_userDidAcceptCloudKitShareWithMetadata_ = + objc.ObjCProtocolListenableMethod< + void Function(NSApplication, CKShareMetadata)>( + _sel_application_userDidAcceptCloudKitShareWithMetadata_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_userDidAcceptCloudKitShareWithMetadata_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(NSApplication, CKShareMetadata) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata.fromFunction( + (ffi.Pointer _, NSApplication arg1, + CKShareMetadata arg2) => + func(arg1, arg2)), + (void Function(NSApplication, CKShareMetadata) func) => + ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata.listener( + (ffi.Pointer _, NSApplication arg1, + CKShareMetadata arg2) => + func(arg1, arg2)), + ); + + /// @return @c YES if the receiving delegate object can respond to key value coding messages for a specific keyed attribute, to-one relationship, or to-many relationship. Return @c NO otherwise. + static final application_delegateHandlesKey_ = + objc.ObjCProtocolMethod( + _sel_application_delegateHandlesKey_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_application_delegateHandlesKey_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication, objc.NSString) func) => + ObjCBlock_bool_ffiVoid_NSApplication_NSString.fromFunction( + (ffi.Pointer _, NSApplication arg1, objc.NSString arg2) => + func(arg1, arg2)), + ); + + /// This method will be called once during application launch at `-[NSApplication finishLaunching]`. + /// + /// @return @c NO if the receiving delegate object wishes to opt-out of system-wide keyboard shortcut localization for all application-supplied menus. Return @c YES by default for apps linked against 12.0 and later SDK. + static final applicationShouldAutomaticallyLocalizeKeyEquivalents_ = + objc.ObjCProtocolMethod( + _sel_applicationShouldAutomaticallyLocalizeKeyEquivalents_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationShouldAutomaticallyLocalizeKeyEquivalents_, + isRequired: false, + isInstanceMethod: true, + ), + (bool Function(NSApplication) func) => + ObjCBlock_bool_ffiVoid_NSApplication.fromFunction( + (ffi.Pointer _, NSApplication arg1) => func(arg1)), + ); + + /// applicationWillFinishLaunching: + static final applicationWillFinishLaunching_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationWillFinishLaunching_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationWillFinishLaunching_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationDidFinishLaunching: + static final applicationDidFinishLaunching_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationDidFinishLaunching_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationDidFinishLaunching_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationWillHide: + static final applicationWillHide_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationWillHide_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationWillHide_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationDidHide: + static final applicationDidHide_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationDidHide_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationDidHide_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationWillUnhide: + static final applicationWillUnhide_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationWillUnhide_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationWillUnhide_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationDidUnhide: + static final applicationDidUnhide_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationDidUnhide_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationDidUnhide_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationWillBecomeActive: + static final applicationWillBecomeActive_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationWillBecomeActive_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationWillBecomeActive_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationDidBecomeActive: + static final applicationDidBecomeActive_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationDidBecomeActive_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationDidBecomeActive_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationWillResignActive: + static final applicationWillResignActive_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationWillResignActive_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationWillResignActive_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationDidResignActive: + static final applicationDidResignActive_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationDidResignActive_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationDidResignActive_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationWillUpdate: + static final applicationWillUpdate_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationWillUpdate_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationWillUpdate_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationDidUpdate: + static final applicationDidUpdate_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationDidUpdate_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationDidUpdate_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationWillTerminate: + static final applicationWillTerminate_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationWillTerminate_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationWillTerminate_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationDidChangeScreenParameters: + static final applicationDidChangeScreenParameters_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationDidChangeScreenParameters_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationDidChangeScreenParameters_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationDidChangeOcclusionState: + static final applicationDidChangeOcclusionState_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationDidChangeOcclusionState_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationDidChangeOcclusionState_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationProtectedDataWillBecomeUnavailable: + static final applicationProtectedDataWillBecomeUnavailable_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationProtectedDataWillBecomeUnavailable_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationProtectedDataWillBecomeUnavailable_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); + + /// applicationProtectedDataDidBecomeAvailable: + static final applicationProtectedDataDidBecomeAvailable_ = + objc.ObjCProtocolListenableMethod( + _sel_applicationProtectedDataDidBecomeAvailable_, + objc.getProtocolMethodSignature( + _protocol_NSApplicationDelegate, + _sel_applicationProtectedDataDidBecomeAvailable_, + isRequired: false, + isInstanceMethod: true, + ), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + (void Function(objc.NSNotification) func) => + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + (ffi.Pointer _, objc.NSNotification arg1) => func(arg1)), + ); +} + +late final _protocol_NSApplicationDelegate = + objc.getProtocol("NSApplicationDelegate"); + +/// NSObject +abstract final class NSObject { + /// Builds an object that implements the NSObject protocol. To implement + /// multiple protocols, use [addToBuilder] or [objc.ObjCProtocolBuilder] directly. + static objc.ObjCObjectBase implement( + {required bool Function(objc.ObjCObjectBase) isEqual_, + required objc.ObjCObjectBase Function() class1, + required objc.ObjCObjectBase Function() self, + required objc.ObjCObjectBase Function(ffi.Pointer) + performSelector_, + required objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + performSelector_withObject_, + required objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + performSelector_withObject_withObject_, + required bool Function() isProxy, + required bool Function(objc.ObjCObjectBase) isKindOfClass_, + required bool Function(objc.ObjCObjectBase) isMemberOfClass_, + required bool Function(objc.Protocol) conformsToProtocol_, + required bool Function(ffi.Pointer) + respondsToSelector_, + required objc.ObjCObjectBase Function() retain, + required void Function() release, + required objc.ObjCObjectBase Function() autorelease, + required int Function() retainCount, + required ffi.Pointer<_NSZone> Function() zone, + required int Function() hash, + required objc.ObjCObjectBase Function() superclass, + required objc.NSString Function() description, + objc.NSString Function()? debugDescription}) { + final builder = objc.ObjCProtocolBuilder(); + NSObject.isEqual_.implement(builder, isEqual_); + NSObject.class1.implement(builder, class1); + NSObject.self.implement(builder, self); + NSObject.performSelector_.implement(builder, performSelector_); + NSObject.performSelector_withObject_ + .implement(builder, performSelector_withObject_); + NSObject.performSelector_withObject_withObject_ + .implement(builder, performSelector_withObject_withObject_); + NSObject.isProxy.implement(builder, isProxy); + NSObject.isKindOfClass_.implement(builder, isKindOfClass_); + NSObject.isMemberOfClass_.implement(builder, isMemberOfClass_); + NSObject.conformsToProtocol_.implement(builder, conformsToProtocol_); + NSObject.respondsToSelector_.implement(builder, respondsToSelector_); + NSObject.retain.implement(builder, retain); + NSObject.release.implement(builder, release); + NSObject.autorelease.implement(builder, autorelease); + NSObject.retainCount.implement(builder, retainCount); + NSObject.zone.implement(builder, zone); + NSObject.hash.implement(builder, hash); + NSObject.superclass.implement(builder, superclass); + NSObject.description.implement(builder, description); + NSObject.debugDescription.implement(builder, debugDescription); + return builder.build(); + } + + /// Adds the implementation of the NSObject protocol to an existing + /// [objc.ObjCProtocolBuilder]. + static void addToBuilder(objc.ObjCProtocolBuilder builder, + {required bool Function(objc.ObjCObjectBase) isEqual_, + required objc.ObjCObjectBase Function() class1, + required objc.ObjCObjectBase Function() self, + required objc.ObjCObjectBase Function(ffi.Pointer) + performSelector_, + required objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + performSelector_withObject_, + required objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + performSelector_withObject_withObject_, + required bool Function() isProxy, + required bool Function(objc.ObjCObjectBase) isKindOfClass_, + required bool Function(objc.ObjCObjectBase) isMemberOfClass_, + required bool Function(objc.Protocol) conformsToProtocol_, + required bool Function(ffi.Pointer) + respondsToSelector_, + required objc.ObjCObjectBase Function() retain, + required void Function() release, + required objc.ObjCObjectBase Function() autorelease, + required int Function() retainCount, + required ffi.Pointer<_NSZone> Function() zone, + required int Function() hash, + required objc.ObjCObjectBase Function() superclass, + required objc.NSString Function() description, + objc.NSString Function()? debugDescription}) { + NSObject.isEqual_.implement(builder, isEqual_); + NSObject.class1.implement(builder, class1); + NSObject.self.implement(builder, self); + NSObject.performSelector_.implement(builder, performSelector_); + NSObject.performSelector_withObject_ + .implement(builder, performSelector_withObject_); + NSObject.performSelector_withObject_withObject_ + .implement(builder, performSelector_withObject_withObject_); + NSObject.isProxy.implement(builder, isProxy); + NSObject.isKindOfClass_.implement(builder, isKindOfClass_); + NSObject.isMemberOfClass_.implement(builder, isMemberOfClass_); + NSObject.conformsToProtocol_.implement(builder, conformsToProtocol_); + NSObject.respondsToSelector_.implement(builder, respondsToSelector_); + NSObject.retain.implement(builder, retain); + NSObject.release.implement(builder, release); + NSObject.autorelease.implement(builder, autorelease); + NSObject.retainCount.implement(builder, retainCount); + NSObject.zone.implement(builder, zone); + NSObject.hash.implement(builder, hash); + NSObject.superclass.implement(builder, superclass); + NSObject.description.implement(builder, description); + NSObject.debugDescription.implement(builder, debugDescription); + } + + /// Builds an object that implements the NSObject protocol. To implement + /// multiple protocols, use [addToBuilder] or [objc.ObjCProtocolBuilder] directly. All + /// methods that can be implemented as listeners will be. + static objc.ObjCObjectBase implementAsListener( + {required bool Function(objc.ObjCObjectBase) isEqual_, + required objc.ObjCObjectBase Function() class1, + required objc.ObjCObjectBase Function() self, + required objc.ObjCObjectBase Function(ffi.Pointer) + performSelector_, + required objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + performSelector_withObject_, + required objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + performSelector_withObject_withObject_, + required bool Function() isProxy, + required bool Function(objc.ObjCObjectBase) isKindOfClass_, + required bool Function(objc.ObjCObjectBase) isMemberOfClass_, + required bool Function(objc.Protocol) conformsToProtocol_, + required bool Function(ffi.Pointer) + respondsToSelector_, + required objc.ObjCObjectBase Function() retain, + required void Function() release, + required objc.ObjCObjectBase Function() autorelease, + required int Function() retainCount, + required ffi.Pointer<_NSZone> Function() zone, + required int Function() hash, + required objc.ObjCObjectBase Function() superclass, + required objc.NSString Function() description, + objc.NSString Function()? debugDescription}) { + final builder = objc.ObjCProtocolBuilder(); + NSObject.isEqual_.implement(builder, isEqual_); + NSObject.class1.implement(builder, class1); + NSObject.self.implement(builder, self); + NSObject.performSelector_.implement(builder, performSelector_); + NSObject.performSelector_withObject_ + .implement(builder, performSelector_withObject_); + NSObject.performSelector_withObject_withObject_ + .implement(builder, performSelector_withObject_withObject_); + NSObject.isProxy.implement(builder, isProxy); + NSObject.isKindOfClass_.implement(builder, isKindOfClass_); + NSObject.isMemberOfClass_.implement(builder, isMemberOfClass_); + NSObject.conformsToProtocol_.implement(builder, conformsToProtocol_); + NSObject.respondsToSelector_.implement(builder, respondsToSelector_); + NSObject.retain.implement(builder, retain); + NSObject.release.implementAsListener(builder, release); + NSObject.autorelease.implement(builder, autorelease); + NSObject.retainCount.implement(builder, retainCount); + NSObject.zone.implement(builder, zone); + NSObject.hash.implement(builder, hash); + NSObject.superclass.implement(builder, superclass); + NSObject.description.implement(builder, description); + NSObject.debugDescription.implement(builder, debugDescription); + return builder.build(); + } + + /// Adds the implementation of the NSObject protocol to an existing + /// [objc.ObjCProtocolBuilder]. All methods that can be implemented as listeners will + /// be. + static void addToBuilderAsListener(objc.ObjCProtocolBuilder builder, + {required bool Function(objc.ObjCObjectBase) isEqual_, + required objc.ObjCObjectBase Function() class1, + required objc.ObjCObjectBase Function() self, + required objc.ObjCObjectBase Function(ffi.Pointer) + performSelector_, + required objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + performSelector_withObject_, + required objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + performSelector_withObject_withObject_, + required bool Function() isProxy, + required bool Function(objc.ObjCObjectBase) isKindOfClass_, + required bool Function(objc.ObjCObjectBase) isMemberOfClass_, + required bool Function(objc.Protocol) conformsToProtocol_, + required bool Function(ffi.Pointer) + respondsToSelector_, + required objc.ObjCObjectBase Function() retain, + required void Function() release, + required objc.ObjCObjectBase Function() autorelease, + required int Function() retainCount, + required ffi.Pointer<_NSZone> Function() zone, + required int Function() hash, + required objc.ObjCObjectBase Function() superclass, + required objc.NSString Function() description, + objc.NSString Function()? debugDescription}) { + NSObject.isEqual_.implement(builder, isEqual_); + NSObject.class1.implement(builder, class1); + NSObject.self.implement(builder, self); + NSObject.performSelector_.implement(builder, performSelector_); + NSObject.performSelector_withObject_ + .implement(builder, performSelector_withObject_); + NSObject.performSelector_withObject_withObject_ + .implement(builder, performSelector_withObject_withObject_); + NSObject.isProxy.implement(builder, isProxy); + NSObject.isKindOfClass_.implement(builder, isKindOfClass_); + NSObject.isMemberOfClass_.implement(builder, isMemberOfClass_); + NSObject.conformsToProtocol_.implement(builder, conformsToProtocol_); + NSObject.respondsToSelector_.implement(builder, respondsToSelector_); + NSObject.retain.implement(builder, retain); + NSObject.release.implementAsListener(builder, release); + NSObject.autorelease.implement(builder, autorelease); + NSObject.retainCount.implement(builder, retainCount); + NSObject.zone.implement(builder, zone); + NSObject.hash.implement(builder, hash); + NSObject.superclass.implement(builder, superclass); + NSObject.description.implement(builder, description); + NSObject.debugDescription.implement(builder, debugDescription); + } + + /// isEqual: + static final isEqual_ = + objc.ObjCProtocolMethod( + _sel_isEqual_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_isEqual_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(objc.ObjCObjectBase) func) => + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunction( + (ffi.Pointer _, objc.ObjCObjectBase arg1) => func(arg1)), + ); + + /// class + static final class1 = objc.ObjCProtocolMethod( + _sel_class, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_class, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// self + static final self = objc.ObjCProtocolMethod( + _sel_self, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_self, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// performSelector: + static final performSelector_ = objc.ObjCProtocolMethod< + objc.ObjCObjectBase Function(ffi.Pointer)>( + _sel_performSelector_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_performSelector_, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function(ffi.Pointer) func) => + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector.fromFunction( + (ffi.Pointer _, ffi.Pointer arg1) => + func(arg1)), + ); + + /// performSelector:withObject: + static final performSelector_withObject_ = objc.ObjCProtocolMethod< + objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase)>( + _sel_performSelector_withObject_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_performSelector_withObject_, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function( + ffi.Pointer, objc.ObjCObjectBase) + func) => + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject + .fromFunction((ffi.Pointer _, + ffi.Pointer arg1, + objc.ObjCObjectBase arg2) => + func(arg1, arg2)), + ); + + /// performSelector:withObject:withObject: + static final performSelector_withObject_withObject_ = objc.ObjCProtocolMethod< + objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase)>( + _sel_performSelector_withObject_withObject_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_performSelector_withObject_withObject_, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function(ffi.Pointer, + objc.ObjCObjectBase, objc.ObjCObjectBase) + func) => + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject + .fromFunction((ffi.Pointer _, + ffi.Pointer arg1, + objc.ObjCObjectBase arg2, + objc.ObjCObjectBase arg3) => + func(arg1, arg2, arg3)), + ); + + /// isProxy + static final isProxy = objc.ObjCProtocolMethod( + _sel_isProxy, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_isProxy, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function() func) => ObjCBlock_bool_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// isKindOfClass: + static final isKindOfClass_ = + objc.ObjCProtocolMethod( + _sel_isKindOfClass_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_isKindOfClass_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(objc.ObjCObjectBase) func) => + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunction( + (ffi.Pointer _, objc.ObjCObjectBase arg1) => func(arg1)), + ); + + /// isMemberOfClass: + static final isMemberOfClass_ = + objc.ObjCProtocolMethod( + _sel_isMemberOfClass_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_isMemberOfClass_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(objc.ObjCObjectBase) func) => + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunction( + (ffi.Pointer _, objc.ObjCObjectBase arg1) => func(arg1)), + ); + + /// conformsToProtocol: + static final conformsToProtocol_ = + objc.ObjCProtocolMethod( + _sel_conformsToProtocol_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_conformsToProtocol_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(objc.Protocol) func) => + ObjCBlock_bool_ffiVoid_Protocol.fromFunction( + (ffi.Pointer _, objc.Protocol arg1) => func(arg1)), + ); + + /// respondsToSelector: + static final respondsToSelector_ = + objc.ObjCProtocolMethod)>( + _sel_respondsToSelector_, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_respondsToSelector_, + isRequired: true, + isInstanceMethod: true, + ), + (bool Function(ffi.Pointer) func) => + ObjCBlock_bool_ffiVoid_objcObjCSelector.fromFunction( + (ffi.Pointer _, ffi.Pointer arg1) => + func(arg1)), + ); + + /// retain + static final retain = objc.ObjCProtocolMethod( + _sel_retain, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_retain, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// release + static final release = objc.ObjCProtocolListenableMethod( + _sel_release, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_release, + isRequired: true, + isInstanceMethod: true, + ), + (void Function() func) => ObjCBlock_ffiVoid_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + (void Function() func) => ObjCBlock_ffiVoid_ffiVoid.listener(( + ffi.Pointer _, + ) => + func()), + ); + + /// autorelease + static final autorelease = + objc.ObjCProtocolMethod( + _sel_autorelease, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_autorelease, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// retainCount + static final retainCount = objc.ObjCProtocolMethod( + _sel_retainCount, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_retainCount, + isRequired: true, + isInstanceMethod: true, + ), + (int Function() func) => ObjCBlock_ffiUnsignedLong_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// zone + static final zone = objc.ObjCProtocolMethod Function()>( + _sel_zone, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_zone, + isRequired: true, + isInstanceMethod: true, + ), + (ffi.Pointer<_NSZone> Function() func) => + ObjCBlock_NSZone_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// hash + static final hash = objc.ObjCProtocolMethod( + _sel_hash, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_hash, + isRequired: true, + isInstanceMethod: true, + ), + (int Function() func) => ObjCBlock_ffiUnsignedLong_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// superclass + static final superclass = + objc.ObjCProtocolMethod( + _sel_superclass, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_superclass, + isRequired: true, + isInstanceMethod: true, + ), + (objc.ObjCObjectBase Function() func) => + ObjCBlock_objcObjCObject_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// description + static final description = objc.ObjCProtocolMethod( + _sel_description, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_description, + isRequired: true, + isInstanceMethod: true, + ), + (objc.NSString Function() func) => ObjCBlock_NSString_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); + + /// debugDescription + static final debugDescription = + objc.ObjCProtocolMethod( + _sel_debugDescription, + objc.getProtocolMethodSignature( + _protocol_NSObject, + _sel_debugDescription, + isRequired: false, + isInstanceMethod: true, + ), + (objc.NSString Function() func) => ObjCBlock_NSString_ffiVoid.fromFunction(( + ffi.Pointer _, + ) => + func()), + ); +} + +late final _protocol_NSObject = objc.getProtocol("NSObject"); +late final _sel_isEqual_ = objc.registerName("isEqual:"); +bool _ObjCBlock_bool_ffiVoid_objcObjCObject_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +bool _ObjCBlock_bool_ffiVoid_objcObjCObject_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_bool_ffiVoid_objcObjCObject extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_objcObjCObject._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_objcObjCObject castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_objcObjCObject._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunctionPointer( + ffi + .Pointer< + ffi + .NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc + .newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCObject_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCObject.fromFunction( + bool Function(ffi.Pointer, objc.ObjCObjectBase) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCObject_closureTrampoline, + false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0, objc.ObjCObjectBase(arg1, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, objc.ObjCObjectBase arg1) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1.pointer); +} + +late final _sel_class = objc.registerName("class"); +ffi.Pointer _ObjCBlock_objcObjCObject_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()(arg0); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer))(arg0); + +class ObjCBlock_objcObjCObject_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_objcObjCObject_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_objcObjCObject_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_objcObjCObject_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid.fromFunction( + objc.ObjCObjectBase Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.ObjCObjectBase call(ffi.Pointer arg0) => objc.ObjCObjectBase( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0), + retain: false, + release: true); +} + +late final _sel_self = objc.registerName("self"); +late final _sel_performSelector_ = objc.registerName("performSelector:"); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector + extends objc.ObjCBlockBase { + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector.fromFunction( + objc.ObjCObjectBase Function( + ffi.Pointer, ffi.Pointer) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => + fn(arg0, arg1).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.ObjCObjectBase call( + ffi.Pointer arg0, ffi.Pointer arg1) => + objc.ObjCObjectBase( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1), + retain: false, + release: true); +} + +late final _sel_performSelector_withObject_ = + objc.registerName("performSelector:withObject:"); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject + extends objc.ObjCBlockBase { + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject._( + pointer, + retain: retain, + release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject.fromFunction( + objc.ObjCObjectBase Function(ffi.Pointer, ffi.Pointer, objc.ObjCObjectBase) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, arg1, objc.ObjCObjectBase(arg2, retain: true, release: true)).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.ObjCObjectBase call(ffi.Pointer arg0, + ffi.Pointer arg1, objc.ObjCObjectBase arg2) => + objc.ObjCObjectBase( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1, arg2.pointer), + retain: false, + release: true); +} + +late final _sel_performSelector_withObject_withObject_ = + objc.registerName("performSelector:withObject:withObject:"); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2, arg3); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2, arg3); + +class ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject + extends objc.ObjCBlockBase { + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject + ._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject.fromFunction( + objc.ObjCObjectBase Function(ffi.Pointer, ffi.Pointer, objc.ObjCObjectBase, objc.ObjCObjectBase) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_objcObjCSelector_objcObjCObject_objcObjCObject_closureTrampoline) + .cast(), + (ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + fn(arg0, arg1, objc.ObjCObjectBase(arg2, retain: true, release: true), objc.ObjCObjectBase(arg3, retain: true, release: true)).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.ObjCObjectBase call( + ffi.Pointer arg0, + ffi.Pointer arg1, + objc.ObjCObjectBase arg2, + objc.ObjCObjectBase arg3) => + objc.ObjCObjectBase( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1, arg2.pointer, arg3.pointer), + retain: false, + release: true); +} + +late final _sel_isProxy = objc.registerName("isProxy"); +bool _ObjCBlock_bool_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction arg0)>>() + .asFunction)>()(arg0); +bool _ObjCBlock_bool_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as bool Function(ffi.Pointer))(arg0); + +class ObjCBlock_bool_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction arg0)>> + ptr) + : this._(objc + .newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_fnPtrTrampoline, false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid.fromFunction(bool Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_closureTrampoline, false) + .cast(), + (ffi.Pointer arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0); +} + +late final _sel_isMemberOfClass_ = objc.registerName("isMemberOfClass:"); +late final _sel_conformsToProtocol_ = objc.registerName("conformsToProtocol:"); +bool _ObjCBlock_bool_ffiVoid_Protocol_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +bool _ObjCBlock_bool_ffiVoid_Protocol_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_bool_ffiVoid_Protocol extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_Protocol._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_Protocol castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_Protocol._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_Protocol.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_Protocol_fnPtrTrampoline, false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_Protocol.fromFunction( + bool Function(ffi.Pointer, objc.Protocol) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_Protocol_closureTrampoline, false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0, + objc.Protocol.castFromPointer(arg1, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, objc.Protocol arg1) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1.pointer); +} + +late final _sel_respondsToSelector_ = objc.registerName("respondsToSelector:"); +bool _ObjCBlock_bool_ffiVoid_objcObjCSelector_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +bool _ObjCBlock_bool_ffiVoid_objcObjCSelector_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_bool_ffiVoid_objcObjCSelector extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_objcObjCSelector._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_objcObjCSelector castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_objcObjCSelector._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCSelector.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCSelector_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCSelector.fromFunction( + bool Function(ffi.Pointer, ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCSelector_closureTrampoline, + false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => + fn(arg0, arg1))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, ffi.Pointer arg1) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1); +} + +late final _sel_retain = objc.registerName("retain"); +late final _sel_release = objc.registerName("release"); +void _ObjCBlock_ffiVoid_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function(ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction arg0)>> + ptr) + : this._(objc + .newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid.fromFunction( + void Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid.listener(void Function(ffi.Pointer) fn) + : this._((objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn(arg0)))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(ffi.Pointer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0); +} + +late final _sel_autorelease = objc.registerName("autorelease"); +late final _sel_retainCount = objc.registerName("retainCount"); +int _ObjCBlock_ffiUnsignedLong_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +int _ObjCBlock_ffiUnsignedLong_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as int Function(ffi.Pointer))(arg0); + +class ObjCBlock_ffiUnsignedLong_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_ffiUnsignedLong_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiUnsignedLong_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiUnsignedLong_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiUnsignedLong_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiUnsignedLong_ffiVoid_fnPtrTrampoline, 0) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiUnsignedLong_ffiVoid.fromFunction( + int Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiUnsignedLong_ffiVoid_closureTrampoline, 0) + .cast(), + (ffi.Pointer arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + int call(ffi.Pointer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0); +} + +late final _sel_zone = objc.registerName("zone"); +ffi.Pointer<_NSZone> _ObjCBlock_NSZone_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer)>()(arg0); +ffi.Pointer<_NSZone> _ObjCBlock_NSZone_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer<_NSZone> Function( + ffi.Pointer))(arg0); + +class ObjCBlock_NSZone_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_NSZone_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSZone_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_NSZone_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSZone_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer arg0)>> + ptr) + : this._( + objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer<_NSZone> Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSZone_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSZone_ffiVoid.fromFunction( + ffi.Pointer<_NSZone> Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer<_NSZone> Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSZone_ffiVoid_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0))); + static ffi.Pointer? _dartFuncTrampoline; + + ffi.Pointer<_NSZone> call(ffi.Pointer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer<_NSZone> Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0); +} + +late final _sel_hash = objc.registerName("hash"); +late final _sel_superclass = objc.registerName("superclass"); +late final _sel_description = objc.registerName("description"); +ffi.Pointer _ObjCBlock_NSString_ffiVoid_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer)>()(arg0); +ffi.Pointer _ObjCBlock_NSString_ffiVoid_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer))(arg0); + +class ObjCBlock_NSString_ffiVoid extends objc.ObjCBlockBase { + ObjCBlock_NSString_ffiVoid._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSString_ffiVoid castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_NSString_ffiVoid._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSString_ffiVoid.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSString_ffiVoid_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSString_ffiVoid.fromFunction( + objc.NSString Function(ffi.Pointer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSString_ffiVoid_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn(arg0).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.NSString call(ffi.Pointer arg0) => + objc.NSString.castFromPointer( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer)>()(pointer, arg0), + retain: false, + release: true); +} + +late final _sel_debugDescription = objc.registerName("debugDescription"); + +/// Return values for `-applicationShouldTerminate:`. +enum NSApplicationTerminateReply { + NSTerminateCancel(0), + NSTerminateNow(1), + NSTerminateLater(2); + + final int value; + const NSApplicationTerminateReply(this.value); + + static NSApplicationTerminateReply fromValue(int value) => switch (value) { + 0 => NSTerminateCancel, + 1 => NSTerminateNow, + 2 => NSTerminateLater, + _ => throw ArgumentError( + "Unknown value for NSApplicationTerminateReply: $value"), + }; +} + +late final _sel_applicationShouldTerminate_ = + objc.registerName("applicationShouldTerminate:"); +int _ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +int _ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as int Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication + extends objc.ObjCBlockBase { + ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication._( + pointer, + retain: retain, + release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.UnsignedLong Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication_fnPtrTrampoline, + 0) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication.fromFunction( + NSApplicationTerminateReply Function(ffi.Pointer, NSApplication) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.UnsignedLong Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSApplicationTerminateReply_ffiVoid_NSApplication_closureTrampoline, 0) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: true, release: true)).value)); + static ffi.Pointer? _dartFuncTrampoline; + + NSApplicationTerminateReply call( + ffi.Pointer arg0, NSApplication arg1) => + NSApplicationTerminateReply.fromValue(pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>()( + pointer, arg0, arg1.pointer)); +} + +late final _sel_application_openURLs_ = + objc.registerName("application:openURLs:"); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject.fromFunction( + void Function(ffi.Pointer, NSApplication, objc.ObjCObjectBase) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: true, release: true), objc.ObjCObjectBase(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject.listener(void Function(ffi.Pointer, NSApplication, objc.ObjCObjectBase) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject( + objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: false, release: true), objc.ObjCObjectBase(arg2, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(ffi.Pointer arg0, NSApplication arg1, + objc.ObjCObjectBase arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer); +} + +late final _sel_application_openFile_ = + objc.registerName("application:openFile:"); +bool _ObjCBlock_bool_ffiVoid_NSApplication_NSString_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +bool _ObjCBlock_bool_ffiVoid_NSApplication_NSString_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_bool_ffiVoid_NSApplication_NSString extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_NSApplication_NSString._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_NSApplication_NSString castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_NSApplication_NSString._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_NSApplication_NSString.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_NSApplication_NSString_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_NSApplication_NSString.fromFunction( + bool Function(ffi.Pointer, NSApplication, objc.NSString) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_NSApplication_NSString_closureTrampoline, false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true), + objc.NSString.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call( + ffi.Pointer arg0, NSApplication arg1, objc.NSString arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer); +} + +late final _sel_application_openFiles_ = + objc.registerName("application:openFiles:"); +late final _sel_application_openTempFile_ = + objc.registerName("application:openTempFile:"); +late final _sel_applicationShouldOpenUntitledFile_ = + objc.registerName("applicationShouldOpenUntitledFile:"); +bool _ObjCBlock_bool_ffiVoid_NSApplication_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +bool _ObjCBlock_bool_ffiVoid_NSApplication_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_bool_ffiVoid_NSApplication extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_NSApplication._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_NSApplication castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_NSApplication._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_NSApplication.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_NSApplication_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_NSApplication.fromFunction( + bool Function(ffi.Pointer, NSApplication) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_NSApplication_closureTrampoline, false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, NSApplication arg1) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1.pointer); +} + +late final _sel_applicationOpenUntitledFile_ = + objc.registerName("applicationOpenUntitledFile:"); +late final _sel_application_openFileWithoutUI_ = + objc.registerName("application:openFileWithoutUI:"); +bool _ObjCBlock_bool_ffiVoid_objcObjCObject_NSString_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +bool _ObjCBlock_bool_ffiVoid_objcObjCObject_NSString_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_bool_ffiVoid_objcObjCObject_NSString + extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_objcObjCObject_NSString._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_objcObjCObject_NSString castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_objcObjCObject_NSString._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCObject_NSString.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCObject_NSString_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_objcObjCObject_NSString.fromFunction(bool Function(ffi.Pointer, objc.ObjCObjectBase, objc.NSString) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_objcObjCObject_NSString_closureTrampoline, false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0, + objc.ObjCObjectBase(arg1, retain: true, release: true), + objc.NSString.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, objc.ObjCObjectBase arg1, + objc.NSString arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer); +} + +late final _sel_application_printFile_ = + objc.registerName("application:printFile:"); + +/// Return values for `-application:printFiles:withSettings:showPrintPanels:`. +enum NSApplicationPrintReply { + NSPrintingCancelled(0), + NSPrintingSuccess(1), + NSPrintingReplyLater(2), + NSPrintingFailure(3); + + final int value; + const NSApplicationPrintReply(this.value); + + static NSApplicationPrintReply fromValue(int value) => switch (value) { + 0 => NSPrintingCancelled, + 1 => NSPrintingSuccess, + 2 => NSPrintingReplyLater, + 3 => NSPrintingFailure, + _ => throw ArgumentError( + "Unknown value for NSApplicationPrintReply: $value"), + }; +} + +late final _sel_application_printFiles_withSettings_showPrintPanels_ = + objc.registerName("application:printFiles:withSettings:showPrintPanels:"); +int _ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3, + bool arg4) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3, + ffi.Bool arg4)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>()(arg0, arg1, arg2, arg3, arg4); +int _ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3, + bool arg4) => + (objc.getBlockClosure(block) as int Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool))(arg0, arg1, arg2, arg3, arg4); + +class ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool + extends objc.ObjCBlockBase { + ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool + ._(pointer, retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.UnsignedLong Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3, + ffi.Bool arg4)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.UnsignedLong Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>( + _ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool_fnPtrTrampoline, + 0) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool.fromFunction(NSApplicationPrintReply Function(ffi.Pointer, NSApplication, objc.ObjCObjectBase, objc.NSDictionary, bool) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.UnsignedLong Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>( + _ObjCBlock_NSApplicationPrintReply_ffiVoid_NSApplication_objcObjCObject_NSDictionary_bool_closureTrampoline, 0) + .cast(), + (ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3, + bool arg4) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: true, release: true), objc.ObjCObjectBase(arg2, retain: true, release: true), objc.NSDictionary.castFromPointer(arg3, retain: true, release: true), arg4) + .value)); + static ffi.Pointer? _dartFuncTrampoline; + + NSApplicationPrintReply call(ffi.Pointer arg0, NSApplication arg1, + objc.ObjCObjectBase arg2, objc.NSDictionary arg3, bool arg4) => + NSApplicationPrintReply.fromValue(pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3, + ffi.Bool arg4)>>() + .asFunction< + int Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>()(pointer, arg0, arg1.pointer, arg2.pointer, arg3.pointer, arg4)); +} + +late final _sel_applicationShouldTerminateAfterLastWindowClosed_ = + objc.registerName("applicationShouldTerminateAfterLastWindowClosed:"); +late final _sel_applicationShouldHandleReopen_hasVisibleWindows_ = + objc.registerName("applicationShouldHandleReopen:hasVisibleWindows:"); +bool _ObjCBlock_bool_ffiVoid_NSApplication_bool_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + bool arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1, ffi.Bool arg2)>>() + .asFunction< + bool Function(ffi.Pointer, ffi.Pointer, + bool)>()(arg0, arg1, arg2); +bool _ObjCBlock_bool_ffiVoid_NSApplication_bool_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + bool arg2) => + (objc.getBlockClosure(block) as bool Function(ffi.Pointer, + ffi.Pointer, bool))(arg0, arg1, arg2); + +class ObjCBlock_bool_ffiVoid_NSApplication_bool extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_NSApplication_bool._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_NSApplication_bool castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_bool_ffiVoid_NSApplication_bool._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_NSApplication_bool.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(ffi.Pointer arg0, + ffi.Pointer arg1, ffi.Bool arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>( + _ObjCBlock_bool_ffiVoid_NSApplication_bool_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_NSApplication_bool.fromFunction( + bool Function(ffi.Pointer, NSApplication, bool) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>( + _ObjCBlock_bool_ffiVoid_NSApplication_bool_closureTrampoline, + false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + bool arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: true, release: true), arg2))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, NSApplication arg1, bool arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Bool arg2)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>()(pointer, arg0, arg1.pointer, arg2); +} + +late final _sel_applicationDockMenu_ = + objc.registerName("applicationDockMenu:"); +ffi.Pointer + _ObjCBlock_NSMenu_ffiVoid_NSApplication_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +ffi.Pointer + _ObjCBlock_NSMenu_ffiVoid_NSApplication_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_NSMenu_ffiVoid_NSApplication extends objc.ObjCBlockBase { + ObjCBlock_NSMenu_ffiVoid_NSApplication._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSMenu_ffiVoid_NSApplication castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_NSMenu_ffiVoid_NSApplication._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSMenu_ffiVoid_NSApplication.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._( + objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSMenu_ffiVoid_NSApplication_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSMenu_ffiVoid_NSApplication.fromFunction( + NSMenu? Function(ffi.Pointer, NSApplication) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSMenu_ffiVoid_NSApplication_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: true, release: true)) + ?.retainAndReturnPointer() ?? + ffi.nullptr)); + static ffi.Pointer? _dartFuncTrampoline; + + NSMenu? call(ffi.Pointer arg0, NSApplication arg1) => pointer + .ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction Function(ffi.Pointer, ffi.Pointer, ffi.Pointer)>() + (pointer, arg0, arg1.pointer) + .address == + 0 + ? null + : NSMenu.castFromPointer( + pointer.ref.invoke + .cast Function(ffi.Pointer block, ffi.Pointer arg0, ffi.Pointer arg1)>>() + .asFunction Function(ffi.Pointer, ffi.Pointer, ffi.Pointer)>()(pointer, arg0, arg1.pointer), + retain: false, + release: true); +} + +late final _sel_application_willPresentError_ = + objc.registerName("application:willPresentError:"); +ffi.Pointer + _ObjCBlock_NSError_ffiVoid_NSApplication_NSError_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +ffi.Pointer + _ObjCBlock_NSError_ffiVoid_NSApplication_NSError_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_NSError_ffiVoid_NSApplication_NSError + extends objc.ObjCBlockBase { + ObjCBlock_NSError_ffiVoid_NSApplication_NSError._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSError_ffiVoid_NSApplication_NSError castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_NSError_ffiVoid_NSApplication_NSError._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSError_ffiVoid_NSApplication_NSError.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSError_ffiVoid_NSApplication_NSError_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSError_ffiVoid_NSApplication_NSError.fromFunction( + objc.NSError Function(ffi.Pointer, NSApplication, objc.NSError) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSError_ffiVoid_NSApplication_NSError_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: true, release: true), objc.NSError.castFromPointer(arg2, retain: true, release: true)).retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + objc.NSError call( + ffi.Pointer arg0, NSApplication arg1, objc.NSError arg2) => + objc.NSError.castFromPointer( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1.pointer, arg2.pointer), + retain: false, + release: true); +} + +late final _sel_application_didRegisterForRemoteNotificationsWithDeviceToken_ = + objc.registerName( + "application:didRegisterForRemoteNotificationsWithDeviceToken:"); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData.fromFunction( + void Function(ffi.Pointer, NSApplication, objc.NSData) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true), + objc.NSData.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData.listener( + void Function(ffi.Pointer, NSApplication, objc.NSData) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: false, release: true), objc.NSData.castFromPointer(arg2, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(ffi.Pointer arg0, NSApplication arg1, objc.NSData arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer); +} + +late final _sel_application_didFailToRegisterForRemoteNotificationsWithError_ = + objc.registerName( + "application:didFailToRegisterForRemoteNotificationsWithError:"); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError.fromFunction( + void Function(ffi.Pointer, NSApplication, objc.NSError) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true), + objc.NSError.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError.listener( + void Function(ffi.Pointer, NSApplication, objc.NSError) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: false, release: true), objc.NSError.castFromPointer(arg2, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call( + ffi.Pointer arg0, NSApplication arg1, objc.NSError arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer); +} + +late final _sel_application_didReceiveRemoteNotification_ = + objc.registerName("application:didReceiveRemoteNotification:"); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary.fromFunction( + void Function(ffi.Pointer, NSApplication, objc.NSDictionary) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true), + objc.NSDictionary.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary.listener( + void Function(ffi.Pointer, NSApplication, objc.NSDictionary) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: false, release: true), objc.NSDictionary.castFromPointer(arg2, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(ffi.Pointer arg0, NSApplication arg1, + objc.NSDictionary arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer); +} + +late final _sel_applicationSupportsSecureRestorableState_ = + objc.registerName("applicationSupportsSecureRestorableState:"); + +/// INIntent +class INIntent extends objc.ObjCObjectBase { + INIntent._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [INIntent] that points to the same underlying object as [other]. + INIntent.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [INIntent] that wraps the given raw object pointer. + INIntent.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [INIntent]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_INIntent); + } +} + +late final _class_INIntent = objc.getClass("INIntent"); +late final _sel_application_handlerForIntent_ = + objc.registerName("application:handlerForIntent:"); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +ffi.Pointer + _ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent + extends objc.ObjCBlockBase { + ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent.fromFunction( + objc.ObjCObjectBase? Function( + ffi.Pointer, NSApplication, INIntent) + fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_objcObjCObject_ffiVoid_NSApplication_INIntent_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: true, release: true), INIntent.castFromPointer(arg2, retain: true, release: true))?.retainAndReturnPointer() ?? ffi.nullptr)); + static ffi.Pointer? _dartFuncTrampoline; + + objc.ObjCObjectBase? call( + ffi.Pointer arg0, NSApplication arg1, INIntent arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>() + (pointer, arg0, arg1.pointer, arg2.pointer) + .address == + 0 + ? null + : objc.ObjCObjectBase(pointer.ref.invoke.cast Function(ffi.Pointer block, ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2)>>().asFunction Function(ffi.Pointer, ffi.Pointer, ffi.Pointer, ffi.Pointer)>()(pointer, arg0, arg1.pointer, arg2.pointer), retain: false, release: true); +} + +late final _sel_application_willEncodeRestorableState_ = + objc.registerName("application:willEncodeRestorableState:"); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder.fromFunction( + void Function(ffi.Pointer, NSApplication, objc.NSCoder) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true), + objc.NSCoder.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder.listener( + void Function(ffi.Pointer, NSApplication, objc.NSCoder) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: false, release: true), objc.NSCoder.castFromPointer(arg2, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call( + ffi.Pointer arg0, NSApplication arg1, objc.NSCoder arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer); +} + +late final _sel_application_didDecodeRestorableState_ = + objc.registerName("application:didDecodeRestorableState:"); +late final _sel_application_willContinueUserActivityWithType_ = + objc.registerName("application:willContinueUserActivityWithType:"); + +/// NSUserActivity +class NSUserActivity extends objc.NSObject { + NSUserActivity._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSUserActivity] that points to the same underlying object as [other]. + NSUserActivity.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSUserActivity] that wraps the given raw object pointer. + NSUserActivity.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSUserActivity]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSUserActivity); + } + + /// initWithActivityType: + NSUserActivity initWithActivityType_(objc.NSString activityType) { + final _ret = _objc_msgSend_120( + this.pointer, _sel_initWithActivityType_, activityType.pointer); + return NSUserActivity.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSUserActivity init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSUserActivity.castFromPointer(_ret, retain: true, release: true); + } + + /// activityType + objc.NSString get activityType { + final _ret = _objc_msgSend_13(this.pointer, _sel_activityType); + return objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// title + objc.NSString? get title { + final _ret = _objc_msgSend_72(this.pointer, _sel_title); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTitle: + set title(objc.NSString? value) { + return _objc_msgSend_140( + this.pointer, _sel_setTitle_, value?.pointer ?? ffi.nullptr); + } + + /// userInfo + objc.NSDictionary? get userInfo { + final _ret = _objc_msgSend_304(this.pointer, _sel_userInfo); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// setUserInfo: + set userInfo(objc.NSDictionary? value) { + return _objc_msgSend_354( + this.pointer, _sel_setUserInfo_, value?.pointer ?? ffi.nullptr); + } + + /// addUserInfoEntriesFromDictionary: + void addUserInfoEntriesFromDictionary_(objc.NSDictionary otherDictionary) { + _objc_msgSend_346(this.pointer, _sel_addUserInfoEntriesFromDictionary_, + otherDictionary.pointer); + } + + /// requiredUserInfoKeys + objc.ObjCObjectBase? get requiredUserInfoKeys { + final _ret = _objc_msgSend_2(this.pointer, _sel_requiredUserInfoKeys); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setRequiredUserInfoKeys: + set requiredUserInfoKeys(objc.ObjCObjectBase? value) { + return _objc_msgSend_3(this.pointer, _sel_setRequiredUserInfoKeys_, + value?.pointer ?? ffi.nullptr); + } + + /// needsSave + bool get needsSave { + return _objc_msgSend_17(this.pointer, _sel_needsSave); + } + + /// setNeedsSave: + set needsSave(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setNeedsSave_, value); + } + + /// webpageURL + objc.NSURL? get webpageURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_webpageURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// setWebpageURL: + set webpageURL(objc.NSURL? value) { + return _objc_msgSend_28( + this.pointer, _sel_setWebpageURL_, value?.pointer ?? ffi.nullptr); + } + + /// referrerURL + objc.NSURL? get referrerURL { + final _ret = _objc_msgSend_27(this.pointer, _sel_referrerURL); + return _ret.address == 0 + ? null + : objc.NSURL.castFromPointer(_ret, retain: true, release: true); + } + + /// setReferrerURL: + set referrerURL(objc.NSURL? value) { + return _objc_msgSend_28( + this.pointer, _sel_setReferrerURL_, value?.pointer ?? ffi.nullptr); + } + + /// expirationDate + objc.NSDate? get expirationDate { + final _ret = _objc_msgSend_289(this.pointer, _sel_expirationDate); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// setExpirationDate: + set expirationDate(objc.NSDate? value) { + return _objc_msgSend_355( + this.pointer, _sel_setExpirationDate_, value?.pointer ?? ffi.nullptr); + } + + /// keywords + objc.ObjCObjectBase get keywords { + final _ret = _objc_msgSend_34(this.pointer, _sel_keywords); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setKeywords: + set keywords(objc.ObjCObjectBase value) { + return _objc_msgSend_35(this.pointer, _sel_setKeywords_, value.pointer); + } + + /// supportsContinuationStreams + bool get supportsContinuationStreams { + return _objc_msgSend_17(this.pointer, _sel_supportsContinuationStreams); + } + + /// setSupportsContinuationStreams: + set supportsContinuationStreams(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setSupportsContinuationStreams_, value); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// targetContentIdentifier + objc.NSString? get targetContentIdentifier { + final _ret = _objc_msgSend_72(this.pointer, _sel_targetContentIdentifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setTargetContentIdentifier: + set targetContentIdentifier(objc.NSString? value) { + return _objc_msgSend_140(this.pointer, _sel_setTargetContentIdentifier_, + value?.pointer ?? ffi.nullptr); + } + + /// becomeCurrent + void becomeCurrent() { + _objc_msgSend_5(this.pointer, _sel_becomeCurrent); + } + + /// resignCurrent + void resignCurrent() { + _objc_msgSend_5(this.pointer, _sel_resignCurrent); + } + + /// invalidate + void invalidate() { + _objc_msgSend_5(this.pointer, _sel_invalidate); + } + + /// getContinuationStreamsWithCompletionHandler: + void getContinuationStreamsWithCompletionHandler_( + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError + completionHandler) { + _objc_msgSend_402( + this.pointer, + _sel_getContinuationStreamsWithCompletionHandler_, + completionHandler.pointer); + } + + /// isEligibleForHandoff + bool get eligibleForHandoff { + return _objc_msgSend_17(this.pointer, _sel_isEligibleForHandoff); + } + + /// setEligibleForHandoff: + set eligibleForHandoff(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setEligibleForHandoff_, value); + } + + /// isEligibleForSearch + bool get eligibleForSearch { + return _objc_msgSend_17(this.pointer, _sel_isEligibleForSearch); + } + + /// setEligibleForSearch: + set eligibleForSearch(bool value) { + return _objc_msgSend_18(this.pointer, _sel_setEligibleForSearch_, value); + } + + /// isEligibleForPublicIndexing + bool get eligibleForPublicIndexing { + return _objc_msgSend_17(this.pointer, _sel_isEligibleForPublicIndexing); + } + + /// setEligibleForPublicIndexing: + set eligibleForPublicIndexing(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setEligibleForPublicIndexing_, value); + } + + /// isEligibleForPrediction + bool get eligibleForPrediction { + return _objc_msgSend_17(this.pointer, _sel_isEligibleForPrediction); + } + + /// setEligibleForPrediction: + set eligibleForPrediction(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setEligibleForPrediction_, value); + } + + /// persistentIdentifier + objc.NSString? get persistentIdentifier { + final _ret = _objc_msgSend_72(this.pointer, _sel_persistentIdentifier); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// setPersistentIdentifier: + set persistentIdentifier(objc.NSString? value) { + return _objc_msgSend_140(this.pointer, _sel_setPersistentIdentifier_, + value?.pointer ?? ffi.nullptr); + } + + /// deleteSavedUserActivitiesWithPersistentIdentifiers:completionHandler: + static void + deleteSavedUserActivitiesWithPersistentIdentifiers_completionHandler_( + objc.NSArray persistentIdentifiers, ObjCBlock_ffiVoid handler) { + _objc_msgSend_403( + _class_NSUserActivity, + _sel_deleteSavedUserActivitiesWithPersistentIdentifiers_completionHandler_, + persistentIdentifiers.pointer, + handler.pointer); + } + + /// deleteAllSavedUserActivitiesWithCompletionHandler: + static void deleteAllSavedUserActivitiesWithCompletionHandler_( + ObjCBlock_ffiVoid handler) { + _objc_msgSend_313( + _class_NSUserActivity, + _sel_deleteAllSavedUserActivitiesWithCompletionHandler_, + handler.pointer); + } + + /// new + static NSUserActivity new1() { + final _ret = _objc_msgSend_34(_class_NSUserActivity, _sel_new); + return NSUserActivity.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSUserActivity allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSUserActivity, _sel_allocWithZone_, zone); + return NSUserActivity.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSUserActivity alloc() { + final _ret = _objc_msgSend_34(_class_NSUserActivity, _sel_alloc); + return NSUserActivity.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSUserActivity = objc.getClass("NSUserActivity"); +late final _sel_initWithActivityType_ = + objc.registerName("initWithActivityType:"); +late final _sel_activityType = objc.registerName("activityType"); +late final _sel_setUserInfo_ = objc.registerName("setUserInfo:"); +final _objc_msgSend_354 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_addUserInfoEntriesFromDictionary_ = + objc.registerName("addUserInfoEntriesFromDictionary:"); +late final _sel_requiredUserInfoKeys = + objc.registerName("requiredUserInfoKeys"); +late final _sel_setRequiredUserInfoKeys_ = + objc.registerName("setRequiredUserInfoKeys:"); +late final _sel_needsSave = objc.registerName("needsSave"); +late final _sel_setNeedsSave_ = objc.registerName("setNeedsSave:"); +late final _sel_webpageURL = objc.registerName("webpageURL"); +late final _sel_setWebpageURL_ = objc.registerName("setWebpageURL:"); +late final _sel_referrerURL = objc.registerName("referrerURL"); +late final _sel_setReferrerURL_ = objc.registerName("setReferrerURL:"); +late final _sel_expirationDate = objc.registerName("expirationDate"); +late final _sel_setExpirationDate_ = objc.registerName("setExpirationDate:"); +final _objc_msgSend_355 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_keywords = objc.registerName("keywords"); +late final _sel_setKeywords_ = objc.registerName("setKeywords:"); +late final _sel_supportsContinuationStreams = + objc.registerName("supportsContinuationStreams"); +late final _sel_setSupportsContinuationStreams_ = + objc.registerName("setSupportsContinuationStreams:"); +late final _sel_targetContentIdentifier = + objc.registerName("targetContentIdentifier"); +late final _sel_setTargetContentIdentifier_ = + objc.registerName("setTargetContentIdentifier:"); +late final _sel_becomeCurrent = objc.registerName("becomeCurrent"); +late final _sel_resignCurrent = objc.registerName("resignCurrent"); +late final _sel_invalidate = objc.registerName("invalidate"); +void _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError.fromFunction( + void Function(NSInputStream?, NSOutputStream?, objc.NSError?) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0.address == 0 ? null : NSInputStream.castFromPointer(arg0, retain: true, release: true), + arg1.address == 0 ? null : NSOutputStream.castFromPointer(arg1, retain: true, release: true), + arg2.address == 0 ? null : objc.NSError.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError.listener( + void Function(NSInputStream?, NSOutputStream?, objc.NSError?) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError( + objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= + ffi.NativeCallable, ffi.Pointer, ffi.Pointer, ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + fn( + arg0.address == 0 + ? null + : NSInputStream.castFromPointer(arg0, retain: false, release: true), + arg1.address == 0 ? null : NSOutputStream.castFromPointer(arg1, retain: false, release: true), + arg2.address == 0 ? null : objc.NSError.castFromPointer(arg2, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(NSInputStream? arg0, NSOutputStream? arg1, objc.NSError? arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, + arg0?.pointer ?? ffi.nullptr, + arg1?.pointer ?? ffi.nullptr, + arg2?.pointer ?? ffi.nullptr); +} + +/// NSInputStream +class NSInputStream extends NSStream { + NSInputStream._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSInputStream] that points to the same underlying object as [other]. + NSInputStream.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSInputStream] that wraps the given raw object pointer. + NSInputStream.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSInputStream]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSInputStream); + } + + /// read:maxLength: + int read_maxLength_(ffi.Pointer buffer, int len) { + return _objc_msgSend_356(this.pointer, _sel_read_maxLength_, buffer, len); + } + + /// getBuffer:length: + bool getBuffer_length_(ffi.Pointer> buffer, + ffi.Pointer len) { + return _objc_msgSend_357(this.pointer, _sel_getBuffer_length_, buffer, len); + } + + /// hasBytesAvailable + bool get hasBytesAvailable { + return _objc_msgSend_17(this.pointer, _sel_hasBytesAvailable); + } + + /// initWithData: + NSInputStream initWithData_(objc.NSData data) { + final _ret = + _objc_msgSend_358(this.pointer, _sel_initWithData_, data.pointer); + return NSInputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithURL: + NSInputStream? initWithURL_(objc.NSURL url) { + final _ret = + _objc_msgSend_316(this.pointer, _sel_initWithURL_, url.pointer); + return _ret.address == 0 + ? null + : NSInputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSInputStream init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSInputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSInputStream new1() { + final _ret = _objc_msgSend_34(_class_NSInputStream, _sel_new); + return NSInputStream.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSInputStream allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSInputStream, _sel_allocWithZone_, zone); + return NSInputStream.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSInputStream alloc() { + final _ret = _objc_msgSend_34(_class_NSInputStream, _sel_alloc); + return NSInputStream.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSInputStream = objc.getClass("NSInputStream"); +late final _sel_read_maxLength_ = objc.registerName("read:maxLength:"); +final _objc_msgSend_356 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Long Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + int Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, int)>(); +late final _sel_getBuffer_length_ = objc.registerName("getBuffer:length:"); +final _objc_msgSend_357 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer>, + ffi.Pointer)>(); +late final _sel_hasBytesAvailable = objc.registerName("hasBytesAvailable"); +late final _sel_initWithData_ = objc.registerName("initWithData:"); +final _objc_msgSend_358 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); + +/// NSStream +class NSStream extends objc.NSObject { + NSStream._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSStream] that points to the same underlying object as [other]. + NSStream.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSStream] that wraps the given raw object pointer. + NSStream.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSStream]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSStream); + } + + /// open + void open() { + _objc_msgSend_5(this.pointer, _sel_open); + } + + /// close + void close() { + _objc_msgSend_5(this.pointer, _sel_close); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// propertyForKey: + objc.ObjCObjectBase? propertyForKey_(objc.NSString key) { + final _ret = + _objc_msgSend_277(this.pointer, _sel_propertyForKey_, key.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setProperty:forKey: + bool setProperty_forKey_(objc.ObjCObjectBase? property, objc.NSString key) { + return _objc_msgSend_359(this.pointer, _sel_setProperty_forKey_, + property?.pointer ?? ffi.nullptr, key.pointer); + } + + /// scheduleInRunLoop:forMode: + void scheduleInRunLoop_forMode_(NSRunLoop aRunLoop, objc.NSString mode) { + _objc_msgSend_371(this.pointer, _sel_scheduleInRunLoop_forMode_, + aRunLoop.pointer, mode.pointer); + } + + /// removeFromRunLoop:forMode: + void removeFromRunLoop_forMode_(NSRunLoop aRunLoop, objc.NSString mode) { + _objc_msgSend_371(this.pointer, _sel_removeFromRunLoop_forMode_, + aRunLoop.pointer, mode.pointer); + } + + /// streamStatus + NSStreamStatus get streamStatus { + final _ret = _objc_msgSend_398(this.pointer, _sel_streamStatus); + return NSStreamStatus.fromValue(_ret); + } + + /// streamError + objc.NSError? get streamError { + final _ret = _objc_msgSend_399(this.pointer, _sel_streamError); + return _ret.address == 0 + ? null + : objc.NSError.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSStream init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSStream.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSStream new1() { + final _ret = _objc_msgSend_34(_class_NSStream, _sel_new); + return NSStream.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSStream allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSStream, _sel_allocWithZone_, zone); + return NSStream.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSStream alloc() { + final _ret = _objc_msgSend_34(_class_NSStream, _sel_alloc); + return NSStream.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSStream = objc.getClass("NSStream"); +late final _sel_open = objc.registerName("open"); +late final _sel_propertyForKey_ = objc.registerName("propertyForKey:"); +late final _sel_setProperty_forKey_ = objc.registerName("setProperty:forKey:"); +final _objc_msgSend_359 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSRunLoop +class NSRunLoop extends objc.NSObject { + NSRunLoop._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSRunLoop] that points to the same underlying object as [other]. + NSRunLoop.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSRunLoop] that wraps the given raw object pointer. + NSRunLoop.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSRunLoop]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSRunLoop); + } + + /// currentRunLoop + static NSRunLoop getCurrentRunLoop() { + final _ret = _objc_msgSend_360(_class_NSRunLoop, _sel_currentRunLoop); + return NSRunLoop.castFromPointer(_ret, retain: true, release: true); + } + + /// mainRunLoop + static NSRunLoop getMainRunLoop() { + final _ret = _objc_msgSend_360(_class_NSRunLoop, _sel_mainRunLoop); + return NSRunLoop.castFromPointer(_ret, retain: true, release: true); + } + + /// currentMode + objc.NSString? get currentMode { + final _ret = _objc_msgSend_72(this.pointer, _sel_currentMode); + return _ret.address == 0 + ? null + : objc.NSString.castFromPointer(_ret, retain: true, release: true); + } + + /// getCFRunLoop + ffi.Pointer<__CFRunLoop> getCFRunLoop() { + return _objc_msgSend_361(this.pointer, _sel_getCFRunLoop); + } + + /// addTimer:forMode: + void addTimer_forMode_(NSTimer timer, objc.NSString mode) { + _objc_msgSend_369( + this.pointer, _sel_addTimer_forMode_, timer.pointer, mode.pointer); + } + + /// addPort:forMode: + void addPort_forMode_(NSPort aPort, objc.NSString mode) { + _objc_msgSend_395( + this.pointer, _sel_addPort_forMode_, aPort.pointer, mode.pointer); + } + + /// removePort:forMode: + void removePort_forMode_(NSPort aPort, objc.NSString mode) { + _objc_msgSend_395( + this.pointer, _sel_removePort_forMode_, aPort.pointer, mode.pointer); + } + + /// limitDateForMode: + objc.NSDate? limitDateForMode_(objc.NSString mode) { + final _ret = + _objc_msgSend_396(this.pointer, _sel_limitDateForMode_, mode.pointer); + return _ret.address == 0 + ? null + : objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// acceptInputForMode:beforeDate: + void acceptInputForMode_beforeDate_( + objc.NSString mode, objc.NSDate limitDate) { + _objc_msgSend_397(this.pointer, _sel_acceptInputForMode_beforeDate_, + mode.pointer, limitDate.pointer); + } + + /// init + NSRunLoop init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSRunLoop.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSRunLoop new1() { + final _ret = _objc_msgSend_34(_class_NSRunLoop, _sel_new); + return NSRunLoop.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSRunLoop allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSRunLoop, _sel_allocWithZone_, zone); + return NSRunLoop.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSRunLoop alloc() { + final _ret = _objc_msgSend_34(_class_NSRunLoop, _sel_alloc); + return NSRunLoop.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSRunLoop = objc.getClass("NSRunLoop"); +late final _sel_currentRunLoop = objc.registerName("currentRunLoop"); +final _objc_msgSend_360 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_mainRunLoop = objc.registerName("mainRunLoop"); +late final _sel_currentMode = objc.registerName("currentMode"); + +final class __CFRunLoop extends ffi.Opaque {} + +late final _sel_getCFRunLoop = objc.registerName("getCFRunLoop"); +final _objc_msgSend_361 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer<__CFRunLoop> Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer<__CFRunLoop> Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSTimer +class NSTimer extends objc.NSObject { + NSTimer._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSTimer] that points to the same underlying object as [other]. + NSTimer.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSTimer] that wraps the given raw object pointer. + NSTimer.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSTimer]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSTimer); + } + + /// timerWithTimeInterval:invocation:repeats: + static NSTimer timerWithTimeInterval_invocation_repeats_( + double ti, objc.NSInvocation invocation, bool yesOrNo) { + final _ret = _objc_msgSend_362( + _class_NSTimer, + _sel_timerWithTimeInterval_invocation_repeats_, + ti, + invocation.pointer, + yesOrNo); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// scheduledTimerWithTimeInterval:invocation:repeats: + static NSTimer scheduledTimerWithTimeInterval_invocation_repeats_( + double ti, objc.NSInvocation invocation, bool yesOrNo) { + final _ret = _objc_msgSend_362( + _class_NSTimer, + _sel_scheduledTimerWithTimeInterval_invocation_repeats_, + ti, + invocation.pointer, + yesOrNo); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// timerWithTimeInterval:target:selector:userInfo:repeats: + static NSTimer timerWithTimeInterval_target_selector_userInfo_repeats_( + double ti, + objc.ObjCObjectBase aTarget, + ffi.Pointer aSelector, + objc.ObjCObjectBase? userInfo, + bool yesOrNo) { + final _ret = _objc_msgSend_363( + _class_NSTimer, + _sel_timerWithTimeInterval_target_selector_userInfo_repeats_, + ti, + aTarget.pointer, + aSelector, + userInfo?.pointer ?? ffi.nullptr, + yesOrNo); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// scheduledTimerWithTimeInterval:target:selector:userInfo:repeats: + static NSTimer + scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_( + double ti, + objc.ObjCObjectBase aTarget, + ffi.Pointer aSelector, + objc.ObjCObjectBase? userInfo, + bool yesOrNo) { + final _ret = _objc_msgSend_363( + _class_NSTimer, + _sel_scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_, + ti, + aTarget.pointer, + aSelector, + userInfo?.pointer ?? ffi.nullptr, + yesOrNo); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// timerWithTimeInterval:repeats:block: + static NSTimer timerWithTimeInterval_repeats_block_( + double interval, bool repeats, ObjCBlock_ffiVoid_NSTimer block) { + final _ret = _objc_msgSend_364( + _class_NSTimer, + _sel_timerWithTimeInterval_repeats_block_, + interval, + repeats, + block.pointer); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// scheduledTimerWithTimeInterval:repeats:block: + static NSTimer scheduledTimerWithTimeInterval_repeats_block_( + double interval, bool repeats, ObjCBlock_ffiVoid_NSTimer block) { + final _ret = _objc_msgSend_364( + _class_NSTimer, + _sel_scheduledTimerWithTimeInterval_repeats_block_, + interval, + repeats, + block.pointer); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithFireDate:interval:repeats:block: + NSTimer initWithFireDate_interval_repeats_block_(objc.NSDate date, + double interval, bool repeats, ObjCBlock_ffiVoid_NSTimer block) { + final _ret = _objc_msgSend_365( + this.pointer, + _sel_initWithFireDate_interval_repeats_block_, + date.pointer, + interval, + repeats, + block.pointer); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithFireDate:interval:target:selector:userInfo:repeats: + NSTimer initWithFireDate_interval_target_selector_userInfo_repeats_( + objc.NSDate date, + double ti, + objc.ObjCObjectBase t, + ffi.Pointer s, + objc.ObjCObjectBase? ui, + bool rep) { + final _ret = _objc_msgSend_366( + this.pointer, + _sel_initWithFireDate_interval_target_selector_userInfo_repeats_, + date.pointer, + ti, + t.pointer, + s, + ui?.pointer ?? ffi.nullptr, + rep); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// fire + void fire() { + _objc_msgSend_5(this.pointer, _sel_fire); + } + + /// fireDate + objc.NSDate get fireDate { + final _ret = _objc_msgSend_367(this.pointer, _sel_fireDate); + return objc.NSDate.castFromPointer(_ret, retain: true, release: true); + } + + /// setFireDate: + set fireDate(objc.NSDate value) { + return _objc_msgSend_368(this.pointer, _sel_setFireDate_, value.pointer); + } + + /// timeInterval + double get timeInterval { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_timeInterval) + : _objc_msgSend_51(this.pointer, _sel_timeInterval); + } + + /// tolerance + double get tolerance { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_tolerance) + : _objc_msgSend_51(this.pointer, _sel_tolerance); + } + + /// setTolerance: + set tolerance(double value) { + return _objc_msgSend_52(this.pointer, _sel_setTolerance_, value); + } + + /// invalidate + void invalidate() { + _objc_msgSend_5(this.pointer, _sel_invalidate); + } + + /// isValid + bool get valid { + return _objc_msgSend_17(this.pointer, _sel_isValid); + } + + /// userInfo + objc.ObjCObjectBase? get userInfo { + final _ret = _objc_msgSend_2(this.pointer, _sel_userInfo); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// init + NSTimer init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSTimer.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSTimer new1() { + final _ret = _objc_msgSend_34(_class_NSTimer, _sel_new); + return NSTimer.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSTimer allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSTimer, _sel_allocWithZone_, zone); + return NSTimer.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSTimer alloc() { + final _ret = _objc_msgSend_34(_class_NSTimer, _sel_alloc); + return NSTimer.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSTimer = objc.getClass("NSTimer"); +late final _sel_timerWithTimeInterval_invocation_repeats_ = + objc.registerName("timerWithTimeInterval:invocation:repeats:"); +final _objc_msgSend_362 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer, + bool)>(); +late final _sel_scheduledTimerWithTimeInterval_invocation_repeats_ = + objc.registerName("scheduledTimerWithTimeInterval:invocation:repeats:"); +late final _sel_timerWithTimeInterval_target_selector_userInfo_repeats_ = objc + .registerName("timerWithTimeInterval:target:selector:userInfo:repeats:"); +final _objc_msgSend_363 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_scheduledTimerWithTimeInterval_target_selector_userInfo_repeats_ = + objc.registerName( + "scheduledTimerWithTimeInterval:target:selector:userInfo:repeats:"); +void _ObjCBlock_ffiVoid_NSTimer_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_NSTimer_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_NSTimer extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSTimer._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSTimer castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSTimer._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSTimer.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSTimer_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSTimer.fromFunction(void Function(NSTimer) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSTimer_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn( + NSTimer.castFromPointer(arg0, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSTimer.listener(void Function(NSTimer) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSTimer(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSTimer_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn( + NSTimer.castFromPointer(arg0, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(NSTimer arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0.pointer); +} + +late final _sel_timerWithTimeInterval_repeats_block_ = + objc.registerName("timerWithTimeInterval:repeats:block:"); +final _objc_msgSend_364 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + double, + bool, + ffi.Pointer)>(); +late final _sel_scheduledTimerWithTimeInterval_repeats_block_ = + objc.registerName("scheduledTimerWithTimeInterval:repeats:block:"); +late final _sel_initWithFireDate_interval_repeats_block_ = + objc.registerName("initWithFireDate:interval:repeats:block:"); +final _objc_msgSend_365 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Bool, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + bool, + ffi.Pointer)>(); +late final _sel_initWithFireDate_interval_target_selector_userInfo_repeats_ = + objc.registerName( + "initWithFireDate:interval:target:selector:userInfo:repeats:"); +final _objc_msgSend_366 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Double, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + double, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_fire = objc.registerName("fire"); +late final _sel_fireDate = objc.registerName("fireDate"); +final _objc_msgSend_367 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_setFireDate_ = objc.registerName("setFireDate:"); +final _objc_msgSend_368 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_timeInterval = objc.registerName("timeInterval"); +late final _sel_tolerance = objc.registerName("tolerance"); +late final _sel_setTolerance_ = objc.registerName("setTolerance:"); +late final _sel_isValid = objc.registerName("isValid"); +late final _sel_addTimer_forMode_ = objc.registerName("addTimer:forMode:"); +final _objc_msgSend_369 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSPort +class NSPort extends objc.NSObject { + NSPort._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSPort] that points to the same underlying object as [other]. + NSPort.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSPort] that wraps the given raw object pointer. + NSPort.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSPort]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, _class_NSPort); + } + + /// port + static NSPort port() { + final _ret = _objc_msgSend_370(_class_NSPort, _sel_port); + return NSPort.castFromPointer(_ret, retain: true, release: true); + } + + /// invalidate + void invalidate() { + _objc_msgSend_5(this.pointer, _sel_invalidate); + } + + /// isValid + bool get valid { + return _objc_msgSend_17(this.pointer, _sel_isValid); + } + + /// setDelegate: + void setDelegate_(objc.ObjCObjectBase? anObject) { + _objc_msgSend_4( + this.pointer, _sel_setDelegate_, anObject?.pointer ?? ffi.nullptr); + } + + /// delegate + objc.ObjCObjectBase? delegate() { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// scheduleInRunLoop:forMode: + void scheduleInRunLoop_forMode_(NSRunLoop runLoop, objc.NSString mode) { + _objc_msgSend_371(this.pointer, _sel_scheduleInRunLoop_forMode_, + runLoop.pointer, mode.pointer); + } + + /// removeFromRunLoop:forMode: + void removeFromRunLoop_forMode_(NSRunLoop runLoop, objc.NSString mode) { + _objc_msgSend_371(this.pointer, _sel_removeFromRunLoop_forMode_, + runLoop.pointer, mode.pointer); + } + + /// reservedSpaceLength + int get reservedSpaceLength { + return _objc_msgSend_81(this.pointer, _sel_reservedSpaceLength); + } + + /// sendBeforeDate:components:from:reserved: + bool sendBeforeDate_components_from_reserved_( + objc.NSDate limitDate, + objc.NSMutableArray? components, + NSPort? receivePort, + int headerSpaceReserved) { + return _objc_msgSend_372( + this.pointer, + _sel_sendBeforeDate_components_from_reserved_, + limitDate.pointer, + components?.pointer ?? ffi.nullptr, + receivePort?.pointer ?? ffi.nullptr, + headerSpaceReserved); + } + + /// sendBeforeDate:msgid:components:from:reserved: + bool sendBeforeDate_msgid_components_from_reserved_( + objc.NSDate limitDate, + int msgID, + objc.NSMutableArray? components, + NSPort? receivePort, + int headerSpaceReserved) { + return _objc_msgSend_373( + this.pointer, + _sel_sendBeforeDate_msgid_components_from_reserved_, + limitDate.pointer, + msgID, + components?.pointer ?? ffi.nullptr, + receivePort?.pointer ?? ffi.nullptr, + headerSpaceReserved); + } + + /// addConnection:toRunLoop:forMode: + void addConnection_toRunLoop_forMode_( + NSConnection conn, NSRunLoop runLoop, objc.NSString mode) { + _objc_msgSend_394(this.pointer, _sel_addConnection_toRunLoop_forMode_, + conn.pointer, runLoop.pointer, mode.pointer); + } + + /// removeConnection:fromRunLoop:forMode: + void removeConnection_fromRunLoop_forMode_( + NSConnection conn, NSRunLoop runLoop, objc.NSString mode) { + _objc_msgSend_394(this.pointer, _sel_removeConnection_fromRunLoop_forMode_, + conn.pointer, runLoop.pointer, mode.pointer); + } + + /// init + NSPort init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSPort.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSPort new1() { + final _ret = _objc_msgSend_34(_class_NSPort, _sel_new); + return NSPort.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSPort allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89(_class_NSPort, _sel_allocWithZone_, zone); + return NSPort.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSPort alloc() { + final _ret = _objc_msgSend_34(_class_NSPort, _sel_alloc); + return NSPort.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSPort = objc.getClass("NSPort"); +late final _sel_port = objc.registerName("port"); +final _objc_msgSend_370 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_scheduleInRunLoop_forMode_ = + objc.registerName("scheduleInRunLoop:forMode:"); +final _objc_msgSend_371 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removeFromRunLoop_forMode_ = + objc.registerName("removeFromRunLoop:forMode:"); +late final _sel_reservedSpaceLength = objc.registerName("reservedSpaceLength"); +late final _sel_sendBeforeDate_components_from_reserved_ = + objc.registerName("sendBeforeDate:components:from:reserved:"); +final _objc_msgSend_372 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int)>(); +late final _sel_sendBeforeDate_msgid_components_from_reserved_ = + objc.registerName("sendBeforeDate:msgid:components:from:reserved:"); +final _objc_msgSend_373 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + int, + ffi.Pointer, + ffi.Pointer, + int)>(); + +/// NSConnection +class NSConnection extends objc.NSObject { + NSConnection._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSConnection] that points to the same underlying object as [other]. + NSConnection.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSConnection] that wraps the given raw object pointer. + NSConnection.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSConnection]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSConnection); + } + + /// statistics + objc.NSDictionary get statistics { + final _ret = _objc_msgSend_223(this.pointer, _sel_statistics); + return objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// allConnections + static objc.NSArray allConnections() { + final _ret = _objc_msgSend_22(_class_NSConnection, _sel_allConnections); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// defaultConnection + static NSConnection defaultConnection() { + final _ret = _objc_msgSend_374(_class_NSConnection, _sel_defaultConnection); + return NSConnection.castFromPointer(_ret, retain: true, release: true); + } + + /// connectionWithRegisteredName:host: + static NSConnection? connectionWithRegisteredName_host_( + objc.NSString name, objc.NSString? hostName) { + final _ret = _objc_msgSend_375( + _class_NSConnection, + _sel_connectionWithRegisteredName_host_, + name.pointer, + hostName?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : NSConnection.castFromPointer(_ret, retain: true, release: true); + } + + /// connectionWithRegisteredName:host:usingNameServer: + static NSConnection? connectionWithRegisteredName_host_usingNameServer_( + objc.NSString name, objc.NSString? hostName, NSPortNameServer server) { + final _ret = _objc_msgSend_380( + _class_NSConnection, + _sel_connectionWithRegisteredName_host_usingNameServer_, + name.pointer, + hostName?.pointer ?? ffi.nullptr, + server.pointer); + return _ret.address == 0 + ? null + : NSConnection.castFromPointer(_ret, retain: true, release: true); + } + + /// rootProxyForConnectionWithRegisteredName:host: + static NSDistantObject? rootProxyForConnectionWithRegisteredName_host_( + objc.NSString name, objc.NSString? hostName) { + final _ret = _objc_msgSend_385( + _class_NSConnection, + _sel_rootProxyForConnectionWithRegisteredName_host_, + name.pointer, + hostName?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : NSDistantObject.castFromPointer(_ret, retain: true, release: true); + } + + /// rootProxyForConnectionWithRegisteredName:host:usingNameServer: + static NSDistantObject? + rootProxyForConnectionWithRegisteredName_host_usingNameServer_( + objc.NSString name, + objc.NSString? hostName, + NSPortNameServer server) { + final _ret = _objc_msgSend_386( + _class_NSConnection, + _sel_rootProxyForConnectionWithRegisteredName_host_usingNameServer_, + name.pointer, + hostName?.pointer ?? ffi.nullptr, + server.pointer); + return _ret.address == 0 + ? null + : NSDistantObject.castFromPointer(_ret, retain: true, release: true); + } + + /// serviceConnectionWithName:rootObject:usingNameServer: + static NSConnection? serviceConnectionWithName_rootObject_usingNameServer_( + objc.NSString name, objc.ObjCObjectBase root, NSPortNameServer server) { + final _ret = _objc_msgSend_387( + _class_NSConnection, + _sel_serviceConnectionWithName_rootObject_usingNameServer_, + name.pointer, + root.pointer, + server.pointer); + return _ret.address == 0 + ? null + : NSConnection.castFromPointer(_ret, retain: true, release: true); + } + + /// serviceConnectionWithName:rootObject: + static NSConnection? serviceConnectionWithName_rootObject_( + objc.NSString name, objc.ObjCObjectBase root) { + final _ret = _objc_msgSend_388(_class_NSConnection, + _sel_serviceConnectionWithName_rootObject_, name.pointer, root.pointer); + return _ret.address == 0 + ? null + : NSConnection.castFromPointer(_ret, retain: true, release: true); + } + + /// requestTimeout + double get requestTimeout { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_requestTimeout) + : _objc_msgSend_51(this.pointer, _sel_requestTimeout); + } + + /// setRequestTimeout: + set requestTimeout(double value) { + return _objc_msgSend_52(this.pointer, _sel_setRequestTimeout_, value); + } + + /// replyTimeout + double get replyTimeout { + return objc.useMsgSendVariants + ? _objc_msgSend_51Fpret(this.pointer, _sel_replyTimeout) + : _objc_msgSend_51(this.pointer, _sel_replyTimeout); + } + + /// setReplyTimeout: + set replyTimeout(double value) { + return _objc_msgSend_52(this.pointer, _sel_setReplyTimeout_, value); + } + + /// rootObject + objc.ObjCObjectBase? get rootObject { + final _ret = _objc_msgSend_2(this.pointer, _sel_rootObject); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setRootObject: + set rootObject(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setRootObject_, value?.pointer ?? ffi.nullptr); + } + + /// delegate + objc.ObjCObjectBase? get delegate { + final _ret = _objc_msgSend_2(this.pointer, _sel_delegate); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// setDelegate: + set delegate(objc.ObjCObjectBase? value) { + return _objc_msgSend_3( + this.pointer, _sel_setDelegate_, value?.pointer ?? ffi.nullptr); + } + + /// independentConversationQueueing + bool get independentConversationQueueing { + return _objc_msgSend_17(this.pointer, _sel_independentConversationQueueing); + } + + /// setIndependentConversationQueueing: + set independentConversationQueueing(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setIndependentConversationQueueing_, value); + } + + /// isValid + bool get valid { + return _objc_msgSend_17(this.pointer, _sel_isValid); + } + + /// rootProxy + NSDistantObject get rootProxy { + final _ret = _objc_msgSend_389(this.pointer, _sel_rootProxy); + return NSDistantObject.castFromPointer(_ret, retain: true, release: true); + } + + /// invalidate + void invalidate() { + _objc_msgSend_5(this.pointer, _sel_invalidate); + } + + /// addRequestMode: + void addRequestMode_(objc.NSString rmode) { + _objc_msgSend_29(this.pointer, _sel_addRequestMode_, rmode.pointer); + } + + /// removeRequestMode: + void removeRequestMode_(objc.NSString rmode) { + _objc_msgSend_29(this.pointer, _sel_removeRequestMode_, rmode.pointer); + } + + /// requestModes + objc.NSArray get requestModes { + final _ret = _objc_msgSend_22(this.pointer, _sel_requestModes); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// registerName: + bool registerName_(objc.NSString? name) { + return _objc_msgSend_390( + this.pointer, _sel_registerName_, name?.pointer ?? ffi.nullptr); + } + + /// registerName:withNameServer: + bool registerName_withNameServer_( + objc.NSString? name, NSPortNameServer server) { + return _objc_msgSend_391(this.pointer, _sel_registerName_withNameServer_, + name?.pointer ?? ffi.nullptr, server.pointer); + } + + /// connectionWithReceivePort:sendPort: + static NSConnection? connectionWithReceivePort_sendPort_( + NSPort? receivePort, NSPort? sendPort) { + final _ret = _objc_msgSend_392( + _class_NSConnection, + _sel_connectionWithReceivePort_sendPort_, + receivePort?.pointer ?? ffi.nullptr, + sendPort?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : NSConnection.castFromPointer(_ret, retain: true, release: true); + } + + /// currentConversation + static objc.ObjCObjectBase? currentConversation() { + final _ret = _objc_msgSend_2(_class_NSConnection, _sel_currentConversation); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// initWithReceivePort:sendPort: + NSConnection? initWithReceivePort_sendPort_( + NSPort? receivePort, NSPort? sendPort) { + final _ret = _objc_msgSend_392( + this.pointer, + _sel_initWithReceivePort_sendPort_, + receivePort?.pointer ?? ffi.nullptr, + sendPort?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : NSConnection.castFromPointer(_ret, retain: true, release: true); + } + + /// sendPort + NSPort get sendPort { + final _ret = _objc_msgSend_370(this.pointer, _sel_sendPort); + return NSPort.castFromPointer(_ret, retain: true, release: true); + } + + /// receivePort + NSPort get receivePort { + final _ret = _objc_msgSend_370(this.pointer, _sel_receivePort); + return NSPort.castFromPointer(_ret, retain: true, release: true); + } + + /// enableMultipleThreads + void enableMultipleThreads() { + _objc_msgSend_5(this.pointer, _sel_enableMultipleThreads); + } + + /// multipleThreadsEnabled + bool get multipleThreadsEnabled { + return _objc_msgSend_17(this.pointer, _sel_multipleThreadsEnabled); + } + + /// addRunLoop: + void addRunLoop_(NSRunLoop runloop) { + _objc_msgSend_393(this.pointer, _sel_addRunLoop_, runloop.pointer); + } + + /// removeRunLoop: + void removeRunLoop_(NSRunLoop runloop) { + _objc_msgSend_393(this.pointer, _sel_removeRunLoop_, runloop.pointer); + } + + /// runInNewThread + void runInNewThread() { + _objc_msgSend_5(this.pointer, _sel_runInNewThread); + } + + /// remoteObjects + objc.NSArray get remoteObjects { + final _ret = _objc_msgSend_22(this.pointer, _sel_remoteObjects); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// localObjects + objc.NSArray get localObjects { + final _ret = _objc_msgSend_22(this.pointer, _sel_localObjects); + return objc.NSArray.castFromPointer(_ret, retain: true, release: true); + } + + /// dispatchWithComponents: + void dispatchWithComponents_(objc.NSArray components) { + _objc_msgSend_280( + this.pointer, _sel_dispatchWithComponents_, components.pointer); + } + + /// init + NSConnection init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSConnection.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSConnection new1() { + final _ret = _objc_msgSend_34(_class_NSConnection, _sel_new); + return NSConnection.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSConnection allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSConnection, _sel_allocWithZone_, zone); + return NSConnection.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSConnection alloc() { + final _ret = _objc_msgSend_34(_class_NSConnection, _sel_alloc); + return NSConnection.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSConnection = objc.getClass("NSConnection"); +late final _sel_statistics = objc.registerName("statistics"); +late final _sel_allConnections = objc.registerName("allConnections"); +late final _sel_defaultConnection = objc.registerName("defaultConnection"); +final _objc_msgSend_374 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_connectionWithRegisteredName_host_ = + objc.registerName("connectionWithRegisteredName:host:"); +final _objc_msgSend_375 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSPortNameServer +class NSPortNameServer extends objc.NSObject { + NSPortNameServer._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSPortNameServer] that points to the same underlying object as [other]. + NSPortNameServer.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSPortNameServer] that wraps the given raw object pointer. + NSPortNameServer.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSPortNameServer]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSPortNameServer); + } + + /// systemDefaultPortNameServer + static NSPortNameServer systemDefaultPortNameServer() { + final _ret = _objc_msgSend_376( + _class_NSPortNameServer, _sel_systemDefaultPortNameServer); + return NSPortNameServer.castFromPointer(_ret, retain: true, release: true); + } + + /// portForName: + NSPort? portForName_(objc.NSString name) { + final _ret = + _objc_msgSend_377(this.pointer, _sel_portForName_, name.pointer); + return _ret.address == 0 + ? null + : NSPort.castFromPointer(_ret, retain: true, release: true); + } + + /// portForName:host: + NSPort? portForName_host_(objc.NSString name, objc.NSString? host) { + final _ret = _objc_msgSend_378(this.pointer, _sel_portForName_host_, + name.pointer, host?.pointer ?? ffi.nullptr); + return _ret.address == 0 + ? null + : NSPort.castFromPointer(_ret, retain: true, release: true); + } + + /// registerPort:name: + bool registerPort_name_(NSPort port, objc.NSString name) { + return _objc_msgSend_379( + this.pointer, _sel_registerPort_name_, port.pointer, name.pointer); + } + + /// removePortForName: + bool removePortForName_(objc.NSString name) { + return _objc_msgSend_183( + this.pointer, _sel_removePortForName_, name.pointer); + } + + /// init + NSPortNameServer init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSPortNameServer.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSPortNameServer new1() { + final _ret = _objc_msgSend_34(_class_NSPortNameServer, _sel_new); + return NSPortNameServer.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSPortNameServer allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSPortNameServer, _sel_allocWithZone_, zone); + return NSPortNameServer.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSPortNameServer alloc() { + final _ret = _objc_msgSend_34(_class_NSPortNameServer, _sel_alloc); + return NSPortNameServer.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSPortNameServer = objc.getClass("NSPortNameServer"); +late final _sel_systemDefaultPortNameServer = + objc.registerName("systemDefaultPortNameServer"); +final _objc_msgSend_376 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_portForName_ = objc.registerName("portForName:"); +final _objc_msgSend_377 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_portForName_host_ = objc.registerName("portForName:host:"); +final _objc_msgSend_378 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_registerPort_name_ = objc.registerName("registerPort:name:"); +final _objc_msgSend_379 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removePortForName_ = objc.registerName("removePortForName:"); +late final _sel_connectionWithRegisteredName_host_usingNameServer_ = + objc.registerName("connectionWithRegisteredName:host:usingNameServer:"); +final _objc_msgSend_380 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// NSDistantObject +class NSDistantObject extends objc.NSProxy { + NSDistantObject._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSDistantObject] that points to the same underlying object as [other]. + NSDistantObject.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSDistantObject] that wraps the given raw object pointer. + NSDistantObject.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSDistantObject]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSDistantObject); + } + + /// proxyWithTarget:connection: + static objc.ObjCObjectBase? proxyWithTarget_connection_( + objc.ObjCObjectBase target, NSConnection connection) { + final _ret = _objc_msgSend_381(_class_NSDistantObject, + _sel_proxyWithTarget_connection_, target.pointer, connection.pointer); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// initWithTarget:connection: + NSDistantObject? initWithTarget_connection_( + objc.ObjCObjectBase target, NSConnection connection) { + final _ret = _objc_msgSend_381(this.pointer, + _sel_initWithTarget_connection_, target.pointer, connection.pointer); + return _ret.address == 0 + ? null + : NSDistantObject.castFromPointer(_ret, retain: true, release: true); + } + + /// proxyWithLocal:connection: + static objc.ObjCObjectBase proxyWithLocal_connection_( + objc.ObjCObjectBase target, NSConnection connection) { + final _ret = _objc_msgSend_382(_class_NSDistantObject, + _sel_proxyWithLocal_connection_, target.pointer, connection.pointer); + return objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// initWithLocal:connection: + NSDistantObject initWithLocal_connection_( + objc.ObjCObjectBase target, NSConnection connection) { + final _ret = _objc_msgSend_382(this.pointer, _sel_initWithLocal_connection_, + target.pointer, connection.pointer); + return NSDistantObject.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithCoder: + NSDistantObject? initWithCoder_(objc.NSCoder inCoder) { + final _ret = + _objc_msgSend_31(this.pointer, _sel_initWithCoder_, inCoder.pointer); + return _ret.address == 0 + ? null + : NSDistantObject.castFromPointer(_ret, retain: true, release: true); + } + + /// setProtocolForProxy: + void setProtocolForProxy_(objc.Protocol? proto) { + _objc_msgSend_383( + this.pointer, _sel_setProtocolForProxy_, proto?.pointer ?? ffi.nullptr); + } + + /// connectionForProxy + NSConnection get connectionForProxy { + final _ret = _objc_msgSend_374(this.pointer, _sel_connectionForProxy); + return NSConnection.castFromPointer(_ret, retain: true, release: true); + } + + /// alloc + static objc.ObjCObjectBase alloc() { + final _ret = _objc_msgSend_34(_class_NSDistantObject, _sel_alloc); + return objc.ObjCObjectBase(_ret, retain: false, release: true); + } + + /// respondsToSelector: + static bool respondsToSelector_(ffi.Pointer aSelector) { + return _objc_msgSend_384( + _class_NSDistantObject, _sel_respondsToSelector_, aSelector); + } +} + +late final _class_NSDistantObject = objc.getClass("NSDistantObject"); +late final _sel_proxyWithTarget_connection_ = + objc.registerName("proxyWithTarget:connection:"); +final _objc_msgSend_381 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithTarget_connection_ = + objc.registerName("initWithTarget:connection:"); +late final _sel_proxyWithLocal_connection_ = + objc.registerName("proxyWithLocal:connection:"); +final _objc_msgSend_382 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_initWithLocal_connection_ = + objc.registerName("initWithLocal:connection:"); +late final _sel_setProtocolForProxy_ = + objc.registerName("setProtocolForProxy:"); +final _objc_msgSend_383 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_connectionForProxy = objc.registerName("connectionForProxy"); +final _objc_msgSend_384 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_rootProxyForConnectionWithRegisteredName_host_ = + objc.registerName("rootProxyForConnectionWithRegisteredName:host:"); +final _objc_msgSend_385 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_rootProxyForConnectionWithRegisteredName_host_usingNameServer_ = + objc.registerName( + "rootProxyForConnectionWithRegisteredName:host:usingNameServer:"); +final _objc_msgSend_386 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_serviceConnectionWithName_rootObject_usingNameServer_ = + objc.registerName("serviceConnectionWithName:rootObject:usingNameServer:"); +final _objc_msgSend_387 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_serviceConnectionWithName_rootObject_ = + objc.registerName("serviceConnectionWithName:rootObject:"); +final _objc_msgSend_388 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_requestTimeout = objc.registerName("requestTimeout"); +late final _sel_setRequestTimeout_ = objc.registerName("setRequestTimeout:"); +late final _sel_replyTimeout = objc.registerName("replyTimeout"); +late final _sel_setReplyTimeout_ = objc.registerName("setReplyTimeout:"); +late final _sel_rootObject = objc.registerName("rootObject"); +late final _sel_setRootObject_ = objc.registerName("setRootObject:"); +late final _sel_independentConversationQueueing = + objc.registerName("independentConversationQueueing"); +late final _sel_setIndependentConversationQueueing_ = + objc.registerName("setIndependentConversationQueueing:"); +late final _sel_rootProxy = objc.registerName("rootProxy"); +final _objc_msgSend_389 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_addRequestMode_ = objc.registerName("addRequestMode:"); +late final _sel_removeRequestMode_ = objc.registerName("removeRequestMode:"); +late final _sel_requestModes = objc.registerName("requestModes"); +late final _sel_registerName_ = objc.registerName("registerName:"); +final _objc_msgSend_390 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_registerName_withNameServer_ = + objc.registerName("registerName:withNameServer:"); +final _objc_msgSend_391 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_connectionWithReceivePort_sendPort_ = + objc.registerName("connectionWithReceivePort:sendPort:"); +final _objc_msgSend_392 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_currentConversation = objc.registerName("currentConversation"); +late final _sel_initWithReceivePort_sendPort_ = + objc.registerName("initWithReceivePort:sendPort:"); +late final _sel_sendPort = objc.registerName("sendPort"); +late final _sel_receivePort = objc.registerName("receivePort"); +late final _sel_enableMultipleThreads = + objc.registerName("enableMultipleThreads"); +late final _sel_multipleThreadsEnabled = + objc.registerName("multipleThreadsEnabled"); +late final _sel_addRunLoop_ = objc.registerName("addRunLoop:"); +final _objc_msgSend_393 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_removeRunLoop_ = objc.registerName("removeRunLoop:"); +late final _sel_runInNewThread = objc.registerName("runInNewThread"); +late final _sel_remoteObjects = objc.registerName("remoteObjects"); +late final _sel_localObjects = objc.registerName("localObjects"); +late final _sel_dispatchWithComponents_ = + objc.registerName("dispatchWithComponents:"); +late final _sel_addConnection_toRunLoop_forMode_ = + objc.registerName("addConnection:toRunLoop:forMode:"); +final _objc_msgSend_394 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removeConnection_fromRunLoop_forMode_ = + objc.registerName("removeConnection:fromRunLoop:forMode:"); +late final _sel_addPort_forMode_ = objc.registerName("addPort:forMode:"); +final _objc_msgSend_395 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_removePort_forMode_ = objc.registerName("removePort:forMode:"); +late final _sel_limitDateForMode_ = objc.registerName("limitDateForMode:"); +final _objc_msgSend_396 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_acceptInputForMode_beforeDate_ = + objc.registerName("acceptInputForMode:beforeDate:"); +final _objc_msgSend_397 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +enum NSStreamStatus { + NSStreamStatusNotOpen(0), + NSStreamStatusOpening(1), + NSStreamStatusOpen(2), + NSStreamStatusReading(3), + NSStreamStatusWriting(4), + NSStreamStatusAtEnd(5), + NSStreamStatusClosed(6), + NSStreamStatusError(7); + + final int value; + const NSStreamStatus(this.value); + + static NSStreamStatus fromValue(int value) => switch (value) { + 0 => NSStreamStatusNotOpen, + 1 => NSStreamStatusOpening, + 2 => NSStreamStatusOpen, + 3 => NSStreamStatusReading, + 4 => NSStreamStatusWriting, + 5 => NSStreamStatusAtEnd, + 6 => NSStreamStatusClosed, + 7 => NSStreamStatusError, + _ => throw ArgumentError("Unknown value for NSStreamStatus: $value"), + }; +} + +late final _sel_streamStatus = objc.registerName("streamStatus"); +final _objc_msgSend_398 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.UnsignedLong Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + int Function( + ffi.Pointer, ffi.Pointer)>(); +late final _sel_streamError = objc.registerName("streamError"); +final _objc_msgSend_399 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, ffi.Pointer)>(); + +/// NSOutputStream +class NSOutputStream extends NSStream { + NSOutputStream._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [NSOutputStream] that points to the same underlying object as [other]. + NSOutputStream.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [NSOutputStream] that wraps the given raw object pointer. + NSOutputStream.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [NSOutputStream]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_NSOutputStream); + } + + /// write:maxLength: + int write_maxLength_(ffi.Pointer buffer, int len) { + return _objc_msgSend_356(this.pointer, _sel_write_maxLength_, buffer, len); + } + + /// hasSpaceAvailable + bool get hasSpaceAvailable { + return _objc_msgSend_17(this.pointer, _sel_hasSpaceAvailable); + } + + /// initToMemory + NSOutputStream initToMemory() { + final _ret = _objc_msgSend_34(this.pointer, _sel_initToMemory); + return NSOutputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// initToBuffer:capacity: + NSOutputStream initToBuffer_capacity_( + ffi.Pointer buffer, int capacity) { + final _ret = _objc_msgSend_400( + this.pointer, _sel_initToBuffer_capacity_, buffer, capacity); + return NSOutputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// initWithURL:append: + NSOutputStream? initWithURL_append_(objc.NSURL url, bool shouldAppend) { + final _ret = _objc_msgSend_401( + this.pointer, _sel_initWithURL_append_, url.pointer, shouldAppend); + return _ret.address == 0 + ? null + : NSOutputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// init + NSOutputStream init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return NSOutputStream.castFromPointer(_ret, retain: true, release: true); + } + + /// new + static NSOutputStream new1() { + final _ret = _objc_msgSend_34(_class_NSOutputStream, _sel_new); + return NSOutputStream.castFromPointer(_ret, retain: false, release: true); + } + + /// allocWithZone: + static NSOutputStream allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = + _objc_msgSend_89(_class_NSOutputStream, _sel_allocWithZone_, zone); + return NSOutputStream.castFromPointer(_ret, retain: false, release: true); + } + + /// alloc + static NSOutputStream alloc() { + final _ret = _objc_msgSend_34(_class_NSOutputStream, _sel_alloc); + return NSOutputStream.castFromPointer(_ret, retain: false, release: true); + } +} + +late final _class_NSOutputStream = objc.getClass("NSOutputStream"); +late final _sel_write_maxLength_ = objc.registerName("write:maxLength:"); +late final _sel_hasSpaceAvailable = objc.registerName("hasSpaceAvailable"); +late final _sel_initToMemory = objc.registerName("initToMemory"); +late final _sel_initToBuffer_capacity_ = + objc.registerName("initToBuffer:capacity:"); +final _objc_msgSend_400 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.UnsignedLong)>>() + .asFunction< + instancetype Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer, int)>(); +late final _sel_initWithURL_append_ = objc.registerName("initWithURL:append:"); +final _objc_msgSend_401 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Bool)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + bool)>(); +late final _sel_getContinuationStreamsWithCompletionHandler_ = + objc.registerName("getContinuationStreamsWithCompletionHandler:"); +final _objc_msgSend_402 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_isEligibleForHandoff = + objc.registerName("isEligibleForHandoff"); +late final _sel_setEligibleForHandoff_ = + objc.registerName("setEligibleForHandoff:"); +late final _sel_isEligibleForSearch = objc.registerName("isEligibleForSearch"); +late final _sel_setEligibleForSearch_ = + objc.registerName("setEligibleForSearch:"); +late final _sel_isEligibleForPublicIndexing = + objc.registerName("isEligibleForPublicIndexing"); +late final _sel_setEligibleForPublicIndexing_ = + objc.registerName("setEligibleForPublicIndexing:"); +late final _sel_isEligibleForPrediction = + objc.registerName("isEligibleForPrediction"); +late final _sel_setEligibleForPrediction_ = + objc.registerName("setEligibleForPrediction:"); +late final _sel_persistentIdentifier = + objc.registerName("persistentIdentifier"); +late final _sel_setPersistentIdentifier_ = + objc.registerName("setPersistentIdentifier:"); +late final _sel_deleteSavedUserActivitiesWithPersistentIdentifiers_completionHandler_ = + objc.registerName( + "deleteSavedUserActivitiesWithPersistentIdentifiers:completionHandler:"); +final _objc_msgSend_403 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_deleteAllSavedUserActivitiesWithCompletionHandler_ = + objc.registerName("deleteAllSavedUserActivitiesWithCompletionHandler:"); +void _ObjCBlock_ffiVoid_NSArray_fnPtrTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>>() + .asFunction)>()(arg0); +void _ObjCBlock_ffiVoid_NSArray_closureTrampoline( + ffi.Pointer block, ffi.Pointer arg0) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer))(arg0); + +class ObjCBlock_ffiVoid_NSArray extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSArray._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSArray castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSArray._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSArray.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSArray_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSArray.fromFunction(void Function(objc.NSArray) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSArray_closureTrampoline) + .cast(), + (ffi.Pointer arg0) => fn( + objc.NSArray.castFromPointer(arg0, + retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSArray.listener(void Function(objc.NSArray) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSArray(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSArray_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0) => fn( + objc.NSArray.castFromPointer(arg0, + retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>? + _dartFuncListenerTrampoline; + + void call(objc.NSArray arg0) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer block, + ffi.Pointer arg0)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(pointer, arg0.pointer); +} + +late final _sel_application_continueUserActivity_restorationHandler_ = + objc.registerName("application:continueUserActivity:restorationHandler:"); +bool + _ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2, arg3); +bool + _ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + (objc.getBlockClosure(block) as bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2, arg3); + +class ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray + extends objc.ObjCBlockBase { + ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray._( + pointer, + retain: retain, + release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray_fnPtrTrampoline, + false) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray.fromFunction(bool Function(ffi.Pointer, NSApplication, NSUserActivity, ObjCBlock_ffiVoid_NSArray) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_bool_ffiVoid_NSApplication_NSUserActivity_ffiVoidNSArray_closureTrampoline, false) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2, ffi.Pointer arg3) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true), + NSUserActivity.castFromPointer(arg2, retain: true, release: true), + ObjCBlock_ffiVoid_NSArray.castFromPointer(arg3, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + bool call(ffi.Pointer arg0, NSApplication arg1, NSUserActivity arg2, + ObjCBlock_ffiVoid_NSArray arg3) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>>() + .asFunction< + bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer, arg3.pointer); +} + +late final _sel_application_didFailToContinueUserActivityWithType_error_ = objc + .registerName("application:didFailToContinueUserActivityWithType:error:"); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2, arg3); +void + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2, arg3); + +class ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError.fromFunction(void Function(ffi.Pointer, NSApplication, objc.NSString, objc.NSError) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2, ffi.Pointer arg3) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true), + objc.NSString.castFromPointer(arg2, retain: true, release: true), + objc.NSError.castFromPointer(arg3, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError.listener( + void Function( + ffi.Pointer, NSApplication, objc.NSString, objc.NSError) + fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= + ffi.NativeCallable, ffi.Pointer, ffi.Pointer, ffi.Pointer, ffi.Pointer)>.listener(_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3) => + fn( + arg0, + NSApplication.castFromPointer(arg1, retain: false, release: true), + objc.NSString.castFromPointer(arg2, retain: false, release: true), + objc.NSError.castFromPointer(arg3, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(ffi.Pointer arg0, NSApplication arg1, objc.NSString arg2, + objc.NSError arg3) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2, + ffi.Pointer arg3)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer, arg3.pointer); +} + +late final _sel_application_didUpdateUserActivity_ = + objc.registerName("application:didUpdateUserActivity:"); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity.fromFunction( + void Function(ffi.Pointer, NSApplication, NSUserActivity) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true), + NSUserActivity.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity.listener( + void Function(ffi.Pointer, NSApplication, NSUserActivity) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: false, release: true), NSUserActivity.castFromPointer(arg2, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(ffi.Pointer arg0, NSApplication arg1, + NSUserActivity arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer); +} + +/// CKShareMetadata +class CKShareMetadata extends objc.ObjCObjectBase { + CKShareMetadata._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super(pointer, retain: retain, release: release); + + /// Constructs a [CKShareMetadata] that points to the same underlying object as [other]. + CKShareMetadata.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [CKShareMetadata] that wraps the given raw object pointer. + CKShareMetadata.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [CKShareMetadata]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_CKShareMetadata); + } +} + +late final _class_CKShareMetadata = objc.getClass("CKShareMetadata"); +late final _sel_application_userDidAcceptCloudKitShareWithMetadata_ = + objc.registerName("application:userDidAcceptCloudKitShareWithMetadata:"); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(arg0, arg1, arg2); +void _ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer))(arg0, arg1, arg2); + +class ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata + extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata + castFromPointer(ffi.Pointer pointer, + {bool retain = false, bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata.fromFunction( + void Function(ffi.Pointer, NSApplication, CKShareMetadata) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, ffi.Pointer arg2) => fn( + arg0, + NSApplication.castFromPointer(arg1, retain: true, release: true), + CKShareMetadata.castFromPointer(arg2, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata.listener( + void Function(ffi.Pointer, NSApplication, CKShareMetadata) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1, + ffi.Pointer arg2) => + fn(arg0, NSApplication.castFromPointer(arg1, retain: false, release: true), CKShareMetadata.castFromPointer(arg2, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(ffi.Pointer arg0, NSApplication arg1, + CKShareMetadata arg2) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1, + ffi.Pointer arg2)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer, arg2.pointer); +} + +late final _sel_application_delegateHandlesKey_ = + objc.registerName("application:delegateHandlesKey:"); +late final _sel_applicationShouldAutomaticallyLocalizeKeyEquivalents_ = + objc.registerName("applicationShouldAutomaticallyLocalizeKeyEquivalents:"); +late final _sel_applicationWillFinishLaunching_ = + objc.registerName("applicationWillFinishLaunching:"); +void _ObjCBlock_ffiVoid_ffiVoid_NSNotification_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +void _ObjCBlock_ffiVoid_ffiVoid_NSNotification_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as void Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_ffiVoid_ffiVoid_NSNotification extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_ffiVoid_NSNotification._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_ffiVoid_NSNotification castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_ffiVoid_NSNotification._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSNotification_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_ffiVoid_NSNotification.fromFunction( + void Function(ffi.Pointer, objc.NSNotification) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_ffiVoid_NSNotification_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0, + objc.NSNotification.castFromPointer(arg1, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_ffiVoid_NSNotification.listener( + void Function(ffi.Pointer, objc.NSNotification) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSNotification( + objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_ffiVoid_NSNotification_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, + ffi.Pointer arg1) => + fn(arg0, objc.NSNotification.castFromPointer(arg1, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(ffi.Pointer arg0, objc.NSNotification arg1) => + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>()(pointer, arg0, arg1.pointer); +} + +late final _sel_applicationDidFinishLaunching_ = + objc.registerName("applicationDidFinishLaunching:"); +late final _sel_applicationWillHide_ = + objc.registerName("applicationWillHide:"); +late final _sel_applicationDidHide_ = objc.registerName("applicationDidHide:"); +late final _sel_applicationWillUnhide_ = + objc.registerName("applicationWillUnhide:"); +late final _sel_applicationDidUnhide_ = + objc.registerName("applicationDidUnhide:"); +late final _sel_applicationWillBecomeActive_ = + objc.registerName("applicationWillBecomeActive:"); +late final _sel_applicationDidBecomeActive_ = + objc.registerName("applicationDidBecomeActive:"); +late final _sel_applicationWillResignActive_ = + objc.registerName("applicationWillResignActive:"); +late final _sel_applicationDidResignActive_ = + objc.registerName("applicationDidResignActive:"); +late final _sel_applicationWillUpdate_ = + objc.registerName("applicationWillUpdate:"); +late final _sel_applicationDidUpdate_ = + objc.registerName("applicationDidUpdate:"); +late final _sel_applicationWillTerminate_ = + objc.registerName("applicationWillTerminate:"); +late final _sel_applicationDidChangeScreenParameters_ = + objc.registerName("applicationDidChangeScreenParameters:"); +late final _sel_applicationDidChangeOcclusionState_ = + objc.registerName("applicationDidChangeOcclusionState:"); +late final _sel_applicationProtectedDataWillBecomeUnavailable_ = + objc.registerName("applicationProtectedDataWillBecomeUnavailable:"); +late final _sel_applicationProtectedDataDidBecomeAvailable_ = + objc.registerName("applicationProtectedDataDidBecomeAvailable:"); + +/// ! @enum ASWebAuthenticationSessionErrorCode +/// @abstract Error code of the NSError object passed in by ASWebAuthenticationSessionCompletionHandler. +/// @constant ASWebAuthenticationSessionErrorCodeCanceledLogin The user has canceled login by cancelling the +/// alert asking for permission to log in to this app, or by dismissing the view controller for loading the +/// authentication webpage. +/// @constant ASWebAuthenticationSessionErrorCodePresentationContextNotProvided A valid presentationContextProvider +/// was not found when -start was called. Ensure this property was not nil when -start was called. +/// @constant ASWebAuthenticationSessionErrorCodePresentationContextInvalid The presentation context returned +/// was not elligible to show the authentication UI. For iOS, validate that the UIWindow is in a foreground scene. +enum ASWebAuthenticationSessionErrorCode { + ASWebAuthenticationSessionErrorCodeCanceledLogin(1), + ASWebAuthenticationSessionErrorCodePresentationContextNotProvided(2), + ASWebAuthenticationSessionErrorCodePresentationContextInvalid(3); + + final int value; + const ASWebAuthenticationSessionErrorCode(this.value); + + static ASWebAuthenticationSessionErrorCode fromValue(int value) => + switch (value) { + 1 => ASWebAuthenticationSessionErrorCodeCanceledLogin, + 2 => ASWebAuthenticationSessionErrorCodePresentationContextNotProvided, + 3 => ASWebAuthenticationSessionErrorCodePresentationContextInvalid, + _ => throw ArgumentError( + "Unknown value for ASWebAuthenticationSessionErrorCode: $value"), + }; +} + +/// ! +/// @class ASWebAuthenticationSession +/// An ASWebAuthenticationSession object can be used to authenticate a user with a web service, even if the web service is run +/// by a third party. ASWebAuthenticationSession puts the user in control of whether they want to use their existing logged-in +/// session from Safari. The app provides a URL that points to the authentication webpage. The page will be loaded in a secure +/// view controller. From the webpage, the user can authenticate herself and grant access to the app. +/// On completion, the service will send a callback URL with an authentication token, and this URL will be passed to the app by +/// ASWebAuthenticationSessionCompletionHandler. +/// +/// The callback URL usually has a custom URL scheme. For the app to receive the callback URL, it needs to either register the +/// custom URL scheme in its Info.plist, or set the scheme to callbackURLScheme argument in the initializer. +/// +/// If the user has already logged into the web service in Safari or other apps via ASWebAuthenticationSession, it is possible to +/// share the existing login information. An alert will be presented to get the user's consent for sharing their existing login +/// information. If the user cancels the alert, the session will be canceled, and the completion handler will be called with +/// the error code ASWebAuthenticationSessionErrorCodeCanceledLogin. +/// +/// If the user taps Cancel when showing the login webpage for the web service, the session will be canceled, and the completion +/// handler will be called with the error code ASWebAuthenticationSessionErrorCodeCanceledLogin. +/// +/// The app can cancel the session by calling -[ASWebAuthenticationSession cancel]. This will also dismiss the view controller that +/// is showing the web service's login page. +class ASWebAuthenticationSession extends objc.NSObject { + ASWebAuthenticationSession._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [ASWebAuthenticationSession] that points to the same underlying object as [other]. + ASWebAuthenticationSession.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [ASWebAuthenticationSession] that wraps the given raw object pointer. + ASWebAuthenticationSession.castFromPointer(ffi.Pointer other, + {bool retain = false, bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [ASWebAuthenticationSession]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0( + obj.pointer, _sel_isKindOfClass_, _class_ASWebAuthenticationSession); + } + + /// ! @abstract Returns an ASWebAuthenticationSession object. + /// @param URL the initial URL pointing to the authentication webpage. Only supports URLs with http:// or https:// schemes. + /// @param callbackURLScheme the custom URL scheme that the app expects in the callback URL. + /// @param completionHandler the completion handler which is called when the session is completed successfully or canceled by user. + ASWebAuthenticationSession initWithURL_callbackURLScheme_completionHandler_( + objc.NSURL URL, + objc.NSString? callbackURLScheme, + ObjCBlock_ffiVoid_NSURL_NSError completionHandler) { + final _ret = _objc_msgSend_404( + this.pointer, + _sel_initWithURL_callbackURLScheme_completionHandler_, + URL.pointer, + callbackURLScheme?.pointer ?? ffi.nullptr, + completionHandler.pointer); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: true, release: true); + } + + /// initWithURL:callback:completionHandler: + ASWebAuthenticationSession initWithURL_callback_completionHandler_( + objc.NSURL URL, + ASWebAuthenticationSessionCallback callback, + ObjCBlock_ffiVoid_NSURL_NSError completionHandler) { + final _ret = _objc_msgSend_407( + this.pointer, + _sel_initWithURL_callback_completionHandler_, + URL.pointer, + callback.pointer, + completionHandler.pointer); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: true, release: true); + } + + /// ! @abstract Provides context to target where in an application's UI the authorization view should be shown. A provider + /// must be set prior to calling -start, otherwise the authorization view cannot be displayed. If deploying to iOS prior to + /// 13.0, the desired window is inferred by the application's key window. + objc.ObjCObjectBase? get presentationContextProvider { + final _ret = + _objc_msgSend_2(this.pointer, _sel_presentationContextProvider); + return _ret.address == 0 + ? null + : objc.ObjCObjectBase(_ret, retain: true, release: true); + } + + /// ! @abstract Provides context to target where in an application's UI the authorization view should be shown. A provider + /// must be set prior to calling -start, otherwise the authorization view cannot be displayed. If deploying to iOS prior to + /// 13.0, the desired window is inferred by the application's key window. + set presentationContextProvider(objc.ObjCObjectBase? value) { + return _objc_msgSend_3(this.pointer, _sel_setPresentationContextProvider_, + value?.pointer ?? ffi.nullptr); + } + + /// ! @abstract Indicates whether this session should ask the browser for an ephemeral session. + /// @discussion Ephemeral web browser sessions do not not share cookies or other browsing data with a user's normal browser session. + /// This value is NO by default. Setting this property after calling -[ASWebAuthenticationSession start] has no effect. + bool get prefersEphemeralWebBrowserSession { + return _objc_msgSend_17( + this.pointer, _sel_prefersEphemeralWebBrowserSession); + } + + /// ! @abstract Indicates whether this session should ask the browser for an ephemeral session. + /// @discussion Ephemeral web browser sessions do not not share cookies or other browsing data with a user's normal browser session. + /// This value is NO by default. Setting this property after calling -[ASWebAuthenticationSession start] has no effect. + set prefersEphemeralWebBrowserSession(bool value) { + return _objc_msgSend_18( + this.pointer, _sel_setPrefersEphemeralWebBrowserSession_, value); + } + + /// Any additional header fields to be set when loading the initial URL. + /// All header field names must start with the "X-" prefix. + objc.NSDictionary? get additionalHeaderFields { + final _ret = _objc_msgSend_304(this.pointer, _sel_additionalHeaderFields); + return _ret.address == 0 + ? null + : objc.NSDictionary.castFromPointer(_ret, retain: true, release: true); + } + + /// Any additional header fields to be set when loading the initial URL. + /// All header field names must start with the "X-" prefix. + set additionalHeaderFields(objc.NSDictionary? value) { + return _objc_msgSend_354(this.pointer, _sel_setAdditionalHeaderFields_, + value?.pointer ?? ffi.nullptr); + } + + /// ! @abstract Returns whether the session can be successfully started. This property returns the same value as calling -start, + /// but without the side effect of actually starting the session. + bool get canStart { + return _objc_msgSend_17(this.pointer, _sel_canStart); + } + + /// ! @abstract Starts the ASWebAuthenticationSession instance after it is instantiated. + /// @discussion start can only be called once for an ASWebAuthenticationSession instance. This also means calling start on a + /// canceled session will fail. + /// @result Returns YES if the session starts successfully. + bool start() { + return _objc_msgSend_17(this.pointer, _sel_start); + } + + /// ! @abstract Cancel an ASWebAuthenticationSession. If the view controller is already presented to load the webpage for + /// authentication, it will be dismissed. Calling cancel on an already canceled session will have no effect. + void cancel() { + _objc_msgSend_5(this.pointer, _sel_cancel); + } + + /// new + static ASWebAuthenticationSession new1() { + final _ret = _objc_msgSend_34(_class_ASWebAuthenticationSession, _sel_new); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: false, release: true); + } + + /// init + ASWebAuthenticationSession init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: true, release: true); + } + + /// allocWithZone: + static ASWebAuthenticationSession allocWithZone_(ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89( + _class_ASWebAuthenticationSession, _sel_allocWithZone_, zone); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static ASWebAuthenticationSession alloc() { + final _ret = + _objc_msgSend_34(_class_ASWebAuthenticationSession, _sel_alloc); + return ASWebAuthenticationSession.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_ASWebAuthenticationSession = + objc.getClass("ASWebAuthenticationSession"); +void _ObjCBlock_ffiVoid_NSURL_NSError_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +void _ObjCBlock_ffiVoid_NSURL_NSError_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as void Function(ffi.Pointer, + ffi.Pointer))(arg0, arg1); + +class ObjCBlock_ffiVoid_NSURL_NSError extends objc.ObjCBlockBase { + ObjCBlock_ffiVoid_NSURL_NSError._(ffi.Pointer pointer, + {bool retain = false, bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_ffiVoid_NSURL_NSError castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_ffiVoid_NSURL_NSError._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSURL_NSError.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSURL_NSError_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_ffiVoid_NSURL_NSError.fromFunction( + void Function(objc.NSURL?, objc.NSError?) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_ffiVoid_NSURL_NSError_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0.address == 0 + ? null + : objc.NSURL.castFromPointer(arg0, retain: true, release: true), + arg1.address == 0 ? null : objc.NSError.castFromPointer(arg1, retain: true, release: true)))); + static ffi.Pointer? _dartFuncTrampoline; + + /// Creates a listener block from a Dart function. + /// + /// This is based on FFI's NativeCallable.listener, and has the same + /// capabilities and limitations. This block can be invoked from any thread, + /// but only supports void functions, and is not run synchronously. See + /// NativeCallable.listener for more details. + /// + /// Note that unlike the default behavior of NativeCallable.listener, listener + /// blocks do not keep the isolate alive. + ObjCBlock_ffiVoid_NSURL_NSError.listener( + void Function(objc.NSURL?, objc.NSError?) fn) + : this._(wrapListenerBlock_ObjCBlock_ffiVoid_NSURL_NSError(objc.newClosureBlock( + (_dartFuncListenerTrampoline ??= + ffi.NativeCallable, ffi.Pointer, ffi.Pointer)>.listener( + _ObjCBlock_ffiVoid_NSURL_NSError_closureTrampoline) + ..keepIsolateAlive = false) + .nativeFunction + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0.address == 0 + ? null + : objc.NSURL + .castFromPointer(arg0, retain: false, release: true), + arg1.address == 0 + ? null + : objc.NSError.castFromPointer(arg1, retain: false, release: true))))); + static ffi.NativeCallable< + ffi.Void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>? _dartFuncListenerTrampoline; + + void call(objc.NSURL? arg0, objc.NSError? arg1) => pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + void Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0?.pointer ?? ffi.nullptr, arg1?.pointer ?? ffi.nullptr); +} + +late final _sel_initWithURL_callbackURLScheme_completionHandler_ = + objc.registerName("initWithURL:callbackURLScheme:completionHandler:"); +final _objc_msgSend_404 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + +/// ASWebAuthenticationSessionCallback +class ASWebAuthenticationSessionCallback extends objc.NSObject { + ASWebAuthenticationSessionCallback._(ffi.Pointer pointer, + {bool retain = false, bool release = false}) + : super.castFromPointer(pointer, retain: retain, release: release); + + /// Constructs a [ASWebAuthenticationSessionCallback] that points to the same underlying object as [other]. + ASWebAuthenticationSessionCallback.castFrom(objc.ObjCObjectBase other) + : this._(other.pointer, retain: true, release: true); + + /// Constructs a [ASWebAuthenticationSessionCallback] that wraps the given raw object pointer. + ASWebAuthenticationSessionCallback.castFromPointer( + ffi.Pointer other, + {bool retain = false, + bool release = false}) + : this._(other, retain: retain, release: release); + + /// Returns whether [obj] is an instance of [ASWebAuthenticationSessionCallback]. + static bool isInstance(objc.ObjCObjectBase obj) { + return _objc_msgSend_0(obj.pointer, _sel_isKindOfClass_, + _class_ASWebAuthenticationSessionCallback); + } + + /// Creates a callback object that matches against URLs with the given custom scheme. + /// @param customScheme The custom scheme that the app expects in the callback URL. + static ASWebAuthenticationSessionCallback callbackWithCustomScheme_( + objc.NSString customScheme) { + final _ret = _objc_msgSend_120(_class_ASWebAuthenticationSessionCallback, + _sel_callbackWithCustomScheme_, customScheme.pointer); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: true, release: true); + } + + /// Creates a callback object that matches against HTTPS URLs with the given host and path. + /// @param host The host that the app expects in the callback URL. The host must be associated with the + /// app using associated web credentials domains. + /// @param path The path that the app expects in the callback URL. + static ASWebAuthenticationSessionCallback callbackWithHTTPSHost_path_( + objc.NSString host, objc.NSString path) { + final _ret = _objc_msgSend_405(_class_ASWebAuthenticationSessionCallback, + _sel_callbackWithHTTPSHost_path_, host.pointer, path.pointer); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: true, release: true); + } + + /// init + ASWebAuthenticationSessionCallback init() { + final _ret = _objc_msgSend_34(this.pointer, _sel_init); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: true, release: true); + } + + /// new + static ASWebAuthenticationSessionCallback new1() { + final _ret = + _objc_msgSend_34(_class_ASWebAuthenticationSessionCallback, _sel_new); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: false, release: true); + } + + /// Check whether a given main-frame navigation URL matches the callback expected by the client app. Handles all URL-based callback strategies, including custom schemes and HTTPS navigations. + /// This is mainly meant for web browsers adopting the ASWebAuthenticationWebBrowser API, but may also be useful for other apps for debugging purposes. + /// @param url The URL to check. + bool matchesURL_(objc.NSURL url) { + return _objc_msgSend_406(this.pointer, _sel_matchesURL_, url.pointer); + } + + /// allocWithZone: + static ASWebAuthenticationSessionCallback allocWithZone_( + ffi.Pointer<_NSZone> zone) { + final _ret = _objc_msgSend_89( + _class_ASWebAuthenticationSessionCallback, _sel_allocWithZone_, zone); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: false, release: true); + } + + /// alloc + static ASWebAuthenticationSessionCallback alloc() { + final _ret = + _objc_msgSend_34(_class_ASWebAuthenticationSessionCallback, _sel_alloc); + return ASWebAuthenticationSessionCallback.castFromPointer(_ret, + retain: false, release: true); + } +} + +late final _class_ASWebAuthenticationSessionCallback = + objc.getClass("ASWebAuthenticationSessionCallback"); +late final _sel_callbackWithCustomScheme_ = + objc.registerName("callbackWithCustomScheme:"); +late final _sel_callbackWithHTTPSHost_path_ = + objc.registerName("callbackWithHTTPSHost:path:"); +final _objc_msgSend_405 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_matchesURL_ = objc.registerName("matchesURL:"); +final _objc_msgSend_406 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + ffi.Bool Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + bool Function(ffi.Pointer, + ffi.Pointer, ffi.Pointer)>(); +late final _sel_initWithURL_callback_completionHandler_ = + objc.registerName("initWithURL:callback:completionHandler:"); +final _objc_msgSend_407 = objc.msgSendPointer + .cast< + ffi.NativeFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>() + .asFunction< + instancetype Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); +late final _sel_presentationContextProvider = + objc.registerName("presentationContextProvider"); +late final _sel_setPresentationContextProvider_ = + objc.registerName("setPresentationContextProvider:"); +late final _sel_prefersEphemeralWebBrowserSession = + objc.registerName("prefersEphemeralWebBrowserSession"); +late final _sel_setPrefersEphemeralWebBrowserSession_ = + objc.registerName("setPrefersEphemeralWebBrowserSession:"); +late final _sel_additionalHeaderFields = + objc.registerName("additionalHeaderFields"); +late final _sel_setAdditionalHeaderFields_ = + objc.registerName("setAdditionalHeaderFields:"); +late final _sel_canStart = objc.registerName("canStart"); +late final _sel_start = objc.registerName("start"); +late final _sel_cancel = objc.registerName("cancel"); + +/// ! @abstract Provides context to target where in an application's UI the authorization view should be shown. +abstract final class ASWebAuthenticationPresentationContextProviding { + /// Builds an object that implements the ASWebAuthenticationPresentationContextProviding protocol. To implement + /// multiple protocols, use [addToBuilder] or [objc.ObjCProtocolBuilder] directly. + static objc.ObjCObjectBase implement( + {required NSWindow Function(ASWebAuthenticationSession) + presentationAnchorForWebAuthenticationSession_}) { + final builder = objc.ObjCProtocolBuilder(); + ASWebAuthenticationPresentationContextProviding + .presentationAnchorForWebAuthenticationSession_ + .implement(builder, presentationAnchorForWebAuthenticationSession_); + return builder.build(); + } + + /// Adds the implementation of the ASWebAuthenticationPresentationContextProviding protocol to an existing + /// [objc.ObjCProtocolBuilder]. + static void addToBuilder(objc.ObjCProtocolBuilder builder, + {required NSWindow Function(ASWebAuthenticationSession) + presentationAnchorForWebAuthenticationSession_}) { + ASWebAuthenticationPresentationContextProviding + .presentationAnchorForWebAuthenticationSession_ + .implement(builder, presentationAnchorForWebAuthenticationSession_); + } + + /// ! @abstract Return the ASPresentationAnchor in the closest proximity to where a user interacted with your app to trigger + /// authentication. If starting an ASWebAuthenticationSession on first launch, use the application's main window. + /// @param session The session requesting a presentation anchor. + /// @result The ASPresentationAnchor most closely associated with the UI used to trigger authentication. + static final presentationAnchorForWebAuthenticationSession_ = + objc.ObjCProtocolMethod( + _sel_presentationAnchorForWebAuthenticationSession_, + objc.getProtocolMethodSignature( + _protocol_ASWebAuthenticationPresentationContextProviding, + _sel_presentationAnchorForWebAuthenticationSession_, + isRequired: true, + isInstanceMethod: true, + ), + (NSWindow Function(ASWebAuthenticationSession) func) => + ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession.fromFunction( + (ffi.Pointer _, ASWebAuthenticationSession arg1) => + func(arg1)), + ); +} + +late final _protocol_ASWebAuthenticationPresentationContextProviding = + objc.getProtocol("ASWebAuthenticationPresentationContextProviding"); +late final _sel_presentationAnchorForWebAuthenticationSession_ = + objc.registerName("presentationAnchorForWebAuthenticationSession:"); +ffi.Pointer + _ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession_fnPtrTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + block.ref.target + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + ffi.Pointer Function(ffi.Pointer, + ffi.Pointer)>()(arg0, arg1); +ffi.Pointer + _ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession_closureTrampoline( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1) => + (objc.getBlockClosure(block) as ffi.Pointer Function( + ffi.Pointer, ffi.Pointer))(arg0, arg1); + +class ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession + extends objc.ObjCBlockBase { + ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession._( + ffi.Pointer pointer, + {bool retain = false, + bool release = true}) + : super(pointer, retain: retain, release: release); + + /// Returns a block that wraps the given raw block pointer. + static ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession castFromPointer( + ffi.Pointer pointer, + {bool retain = false, + bool release = false}) { + return ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession._(pointer, + retain: retain, release: release); + } + + /// Creates a block from a C function pointer. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession.fromFunctionPointer( + ffi.Pointer< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer arg0, + ffi.Pointer arg1)>> + ptr) + : this._(objc.newPointerBlock( + _cFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession_fnPtrTrampoline) + .cast(), + ptr.cast())); + static ffi.Pointer? _cFuncTrampoline; + + /// Creates a block from a Dart function. + /// + /// This block must be invoked by native code running on the same thread as + /// the isolate that registered it. Invoking the block on the wrong thread + /// will result in a crash. + ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession.fromFunction( + NSWindow Function(ffi.Pointer, ASWebAuthenticationSession) fn) + : this._(objc.newClosureBlock( + _dartFuncTrampoline ??= ffi.Pointer.fromFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>( + _ObjCBlock_NSWindow_ffiVoid_ASWebAuthenticationSession_closureTrampoline) + .cast(), + (ffi.Pointer arg0, ffi.Pointer arg1) => fn( + arg0, + ASWebAuthenticationSession.castFromPointer(arg1, retain: true, release: true)) + .retainAndReturnPointer())); + static ffi.Pointer? _dartFuncTrampoline; + + NSWindow call(ffi.Pointer arg0, ASWebAuthenticationSession arg1) => + NSWindow.castFromPointer( + pointer.ref.invoke + .cast< + ffi.NativeFunction< + ffi.Pointer Function( + ffi.Pointer block, + ffi.Pointer arg0, + ffi.Pointer arg1)>>() + .asFunction< + ffi.Pointer Function( + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>()( + pointer, arg0, arg1.pointer), + retain: false, + release: true); +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/native_auth.platform_io.dart b/packages/native/auth/native_auth_flutter/lib/src/native_auth.platform_io.dart new file mode 100644 index 0000000..af9179e --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/native_auth.platform_io.dart @@ -0,0 +1,57 @@ +import 'dart:io'; + +import 'package:logging/logging.dart'; +import 'package:meta/meta.dart'; +import 'package:native_auth_flutter/native_auth_flutter.dart'; +import 'package:native_auth_flutter/src/platform/native_auth.android.dart'; +import 'package:native_auth_flutter/src/platform/native_auth.desktop.dart'; +import 'package:native_auth_flutter/src/platform/native_auth.ios.dart'; +import 'package:native_auth_flutter/src/platform/native_auth.macos.dart'; + +abstract base class NativeAuthPlatform implements NativeAuth { + factory NativeAuthPlatform({ + Logger? logger, + }) { + if (Platform.isAndroid) { + return NativeAuthAndroid(logger: logger); + } + if (Platform.isIOS) { + return NativeAuthIos(logger: logger); + } + if (Platform.isMacOS) { + return NativeAuthMacOs(logger: logger); + } + if (Platform.isWindows || Platform.isLinux) { + return NativeAuthDesktop(logger: logger); + } + throw UnsupportedError('Unsupported platform: ${Platform.operatingSystem}'); + } + + @protected + NativeAuthPlatform.base(); + + @nonVirtual + Future signInWithOAuthRedirect({ + required Uri signInUri, + required CallbackScheme callbackScheme, + }) async { + try { + final redirectUri = await performAuthorizationRedirect( + uri: signInUri, + callbackScheme: callbackScheme, + ); + final result = OAuthResult.fromUri(redirectUri); + return switch (result) { + final OAuthCode code => code, + final OAuthException error => throw error, + }; + } on NativeAuthException { + rethrow; + } on Object catch (error, stack) { + Error.throwWithStackTrace( + NativeAuthException('Error during redirect', underlyingError: error), + stack, + ); + } + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/native_auth.platform_stub.dart b/packages/native/auth/native_auth_flutter/lib/src/native_auth.platform_stub.dart new file mode 100644 index 0000000..3311121 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/native_auth.platform_stub.dart @@ -0,0 +1,22 @@ +import 'package:logging/logging.dart'; +import 'package:native_auth_flutter/native_auth_flutter.dart'; + +final class NativeAuthPlatform implements NativeAuth { + NativeAuthPlatform({Logger? logger}); + + @override + NativeAuthCallbackSession startAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) { + throw UnsupportedError('Native auth is not supported on this platform'); + } + + @override + Future performAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) { + throw UnsupportedError('Native auth is not supported on this platform'); + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/native_auth.platform_web.dart b/packages/native/auth/native_auth_flutter/lib/src/native_auth.platform_web.dart new file mode 100644 index 0000000..3ac4e55 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/native_auth.platform_web.dart @@ -0,0 +1,53 @@ +import 'dart:async'; + +import 'package:logging/logging.dart'; +import 'package:native_auth_flutter/native_auth_flutter.dart'; +import 'package:native_auth_flutter/src/model/callback_session.dart'; +import 'package:path/path.dart'; +import 'package:web/web.dart'; + +final class NativeAuthPlatform implements NativeAuth { + NativeAuthPlatform({Logger? logger}) + : _logger = logger ?? Logger('NativeAuth'); + + final Logger _logger; + + /// The base URL, to which all local paths are relative. + // ignore: unused_element + String get _baseUrl { + final baseElement = document.querySelector('base'); + final basePath = baseElement?.getAttribute('href') ?? '/'; + return url.join(window.location.origin, basePath); + } + + static const _sessionStorageKey = 'dev.celest.native_auth:currentSession'; + + @override + NativeAuthCallbackSession startAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) { + final sessionId = NativeAuthCallbackSessionImpl.nextId(); + window.sessionStorage.setItem(_sessionStorageKey, '$sessionId'); + final session = NativeAuthCallbackSessionImpl( + sessionId, + Completer(), + () => window.sessionStorage.removeItem(_sessionStorageKey), + ); + _logger.finer('Redirect flow started'); + window.open(uri.toString(), '_self'); + return session; + } + + @override + Future performAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) async { + final session = startAuthorizationRedirect( + uri: uri, + callbackScheme: callbackScheme, + ); + return session.redirectUri; + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.android.dart b/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.android.dart new file mode 100644 index 0000000..f000466 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.android.dart @@ -0,0 +1,144 @@ +import 'dart:async'; + +import 'package:jni/jni.dart'; +import 'package:logging/logging.dart'; +import 'package:native_auth_flutter/native_auth_flutter.dart'; +import 'package:native_auth_flutter/src/model/callback_session.dart'; +import 'package:native_auth_flutter/src/native/android/jni_bindings.ffi.dart' + as android; +import 'package:native_auth_flutter/src/native_auth.platform_io.dart'; + +final class NativeAuthAndroid extends NativeAuthPlatform { + NativeAuthAndroid({Logger? logger}) + : _logger = logger ?? Logger('NativeAuth'), + super.base() { + _nativeAuth; // Ensure initialized + _listenForRedirects(); + } + + static final StreamController + _redirectStreamController = StreamController.broadcast(); + static final _redirectCallback = android.NativeAuthCallback.implement( + android.$NativeAuthCallbackImpl( + T: android.NativeAuthRedirectResult.type, + onMessage: _redirectStreamController.add, + ), + ); + static final _nativeAuth = android.NativeAuth( + android.FlutterActivity.fromReference(Jni.getCurrentActivity()), + _redirectCallback, + ); + + final Logger _logger; + + NativeAuthCallbackSession? _currentSession; + Completer? _currentCompleter; + + void _listenForRedirects() { + _redirectStreamController.stream.listen( + (android.NativeAuthRedirectResult state) { + _logger.finest('Redirect result: $state'); + _complete((completer) { + final sessionId = state.getId(); + final resultCode = state.getResultCode(); + switch (resultCode) { + case android.NativeAuth.RESULT_OK: + final url = state.getUri().toString(); + completer.complete(Uri.parse(url)); + case android.NativeAuth.RESULT_CANCELED: + completer.completeError( + NativeAuthException( + 'Redirect canceled by user (id=$sessionId)', + ), + ); + case android.NativeAuth.RESULT_FAILURE: + completer.completeError( + NativeAuthException( + 'Redirect failed (id=$sessionId)', + underlyingError: state.getError(), + ), + ); + default: + completer.completeError( + StateError('Unknown result code ($resultCode): $state'), + ); + } + }); + }, + onError: (error, stackTrace) { + _logger.severe('Error in redirect stream', error); + _complete((completer) { + completer.completeError( + NativeAuthException( + 'Unexpected error', + underlyingError: error, + ), + stackTrace, + ); + }); + }, + cancelOnError: false, + ); + } + + /// Completes the current redirect operation. + void _complete(void Function(Completer completer) action) { + try { + final currentCompleter = _currentCompleter; + if (currentCompleter == null) { + return _logger.warning( + 'Received redirect without a pending operation', + ); + } else if (currentCompleter.isCompleted) { + return _logger.warning( + 'Received redirect after the operation was completed', + ); + } + action(currentCompleter); + } finally { + _currentCompleter = null; + _currentSession = null; + } + } + + @override + NativeAuthCallbackSession startAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) { + if (callbackScheme is! CallbackSchemeCustom) { + throw UnsupportedError( + 'Only custom redirect schemes are supported on this platform', + ); + } + if (_currentSession case final currentSession?) { + throw NativeAuthException( + 'Another redirect operation is in progress (id=${currentSession.id})', + ); + } + final sessionId = NativeAuthCallbackSessionImpl.nextId(); + final cancellationToken = _nativeAuth.startRedirect( + sessionId, + android.Uri.parse(uri.toString().toJString()), + ); + _currentCompleter = Completer(); + _logger.finer('Redirect flow started'); + return _currentSession = NativeAuthCallbackSessionImpl( + sessionId, + _currentCompleter!, + cancellationToken.cancel, + ); + } + + @override + Future performAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) async { + final session = startAuthorizationRedirect( + uri: uri, + callbackScheme: callbackScheme, + ); + return session.redirectUri; + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.desktop.dart b/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.desktop.dart new file mode 100644 index 0000000..b0b0912 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.desktop.dart @@ -0,0 +1,251 @@ +import 'dart:async'; +import 'dart:convert'; +import 'dart:io'; + +import 'package:logging/logging.dart'; +import 'package:native_auth_flutter/native_auth_flutter.dart'; +import 'package:native_auth_flutter/src/model/callback_session.dart'; +import 'package:native_auth_flutter/src/native_auth.platform_io.dart'; +import 'package:stream_transform/stream_transform.dart'; + +base class NativeAuthDesktop extends NativeAuthPlatform { + NativeAuthDesktop({Logger? logger}) + : logger = logger ?? Logger('NativeAuth'), + super.base(); + + final Logger? logger; + + /// Launches the given URL using the platform's default browser. + Future _launchUrl(String url) async { + final String command; + if (Platform.isWindows) { + command = 'powershell'; + } else if (Platform.isLinux) { + command = 'xdg-open'; + } else if (Platform.isMacOS) { + command = 'open'; + } else { + throw UnsupportedError('Unsupported OS: ${Platform.operatingSystem}'); + } + + final arguments = Platform.isWindows ? ['start-process', '"$url"'] : [url]; + final couldNotLaunch = '"$command ${arguments.join(' ')}" command failed'; + try { + final res = await Process.run( + command, + arguments, + stdoutEncoding: utf8, + stderrEncoding: utf8, + ); + if (res.exitCode != 0) { + throw NativeAuthException( + couldNotLaunch, + underlyingError: '${res.stdout}\n${res.stderr}', + ); + } + } on Exception catch (e) { + throw NativeAuthException( + couldNotLaunch, + underlyingError: e, + ); + } + } + + Future _respond( + HttpRequest request, + int statusCode, + String response, { + Map? headers, + }) async { + request.response.statusCode = statusCode; + headers?.forEach(request.response.headers.add); + request.response.writeln(response); + await request.response.flush(); + await request.response.close(); + } + + @override + NativeAuthCallbackSession startAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) { + final (port, expectedPath) = switch (callbackScheme) { + CallbackSchemeLocalhost(:final port, :final path) => (port, path), + CallbackSchemeCustom() => throw ArgumentError.value( + callbackScheme, + 'callbackScheme', + 'Custom schemes are not supported on this platform', + ), + CallbackSchemeHttps() => throw ArgumentError.value( + callbackScheme, + 'callbackScheme', + 'HTTPS scheme is not supported on this platform', + ), + }; + + final Future server = HttpServer.bind( + InternetAddress.loopbackIPv4, + port, + ).onError((error, stack) { + throw NativeAuthException( + 'Failed to bind to http://localhost:$port', + underlyingError: error, + ); + }); + + final callback = Completer(); + final cancelSignal = Completer(); + callback.complete( + server.then((server) async { + await _launchUrl(uri.toString()); + logger?.fine('Listening for callback on $callbackScheme'); + return _listenForCallback( + server, + expectedPath, + cancelSignal.future, + ); + }), + ); + + return NativeAuthCallbackSessionImpl( + NativeAuthCallbackSessionImpl.nextId(), + callback, + cancelSignal.complete, + ); + } + + @override + Future performAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) async { + final session = startAuthorizationRedirect( + uri: uri, + callbackScheme: callbackScheme, + ); + return session.redirectUri; + } + + Future _listenForCallback( + HttpServer server, + String expectedPath, + Future cancelSignal, + ) async { + cancelSignal = cancelSignal.then((_) { + logger?.severe('Authorization flow was cancelled by user'); + throw const NativeAuthException( + 'Authorization flow was cancelled by user', + ); + }); + try { + late Uri result; + await for (final request in server.takeUntil(cancelSignal)) { + logger?.fine('${request.method} ${request.uri.path}'); + if (request.method != 'GET') { + await _respond( + request, + HttpStatus.methodNotAllowed, + 'Only GET requests are allowed', + ); + continue; + } + + result = request.requestedUri; + if (expectedPath != '/*') { + if (result.path != expectedPath) { + await _respond( + request, + HttpStatus.notFound, + 'Not found', + ); + continue; + } + } + + await _respond( + request, + HttpStatus.ok, + _htmlForParams(result.queryParameters, signIn: true), + headers: { + HttpHeaders.contentTypeHeader: 'text/html', + }, + ); + break; + } + return result; + } on Object catch (error, stack) { + Error.throwWithStackTrace( + NativeAuthException('Error during redirect', underlyingError: error), + stack, + ); + } finally { + server.close(force: true).ignore(); + } + } + + static String _html(String pageTitle, String title, String message) => ''' + + + + + + + $pageTitle + + + +
+
+

$title

+

$message

+
+
+ +'''; + + static String _htmlForParams( + Map parameters, { + required bool signIn, + }) { + if (parameters.containsKey('error')) { + return _html( + 'Authentication Error', + 'Something went wrong.', + 'An error occurred. Please return to the application for more info.', + ); + } + return _html( + 'Complete', + 'Callback complete.', + 'You can now close this window.', + ); + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.ios.dart b/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.ios.dart new file mode 100644 index 0000000..151c169 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.ios.dart @@ -0,0 +1,139 @@ +import 'dart:async'; +import 'dart:ffi'; + +import 'package:logging/logging.dart'; +import 'package:native_auth_flutter/native_auth_flutter.dart'; +import 'package:native_auth_flutter/src/model/callback_session.dart'; +import 'package:native_auth_flutter/src/native/ios/authentication_services.ffi.dart'; +import 'package:native_auth_flutter/src/native_auth.platform_io.dart'; +import 'package:objective_c/objective_c.dart' as objc; + +final class NativeAuthIos extends NativeAuthPlatform { + NativeAuthIos({Logger? logger}) + : logger = logger ?? Logger('NativeAuth'), + super.base(); + + final Logger? logger; + + // Hold strong references to the callbacks to prevent them from being + // garbage collected. + ObjCBlock_ffiVoid_NSURL_NSError? _currentCompletionHandler; + late final _presentationContextProvider = + ASWebAuthenticationPresentationContextProviding.implement( + presentationAnchorForWebAuthenticationSession_: (session) { + final keyWindow = UIApplication.getSharedApplication().keyWindow; + if (keyWindow == null) { + logger?.severe('Failed to get key window'); + session.cancel(); + return UIWindow.castFromPointer(nullptr); + } + return keyWindow; + }, + ); + + void _cleanUp() { + _currentCompletionHandler?.release(); + _currentCompletionHandler = null; + } + + @override + NativeAuthCallbackSession startAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) { + final url = objc.NSURL.URLWithString_(uri.toString().toNSString()); + if (url == null) { + logger?.severe('Invalid URL: $uri'); + throw NativeAuthException('Invalid URL: $uri'); + } + final completion = Completer(); + final completionHandler = + ObjCBlock_ffiVoid_NSURL_NSError.listener((url, error) { + final uri = switch (url?.absoluteString?.toString()) { + final url? => Uri.tryParse(url), + _ => null, + }; + logger?.fine('Redirect completion: url=$uri, error=$error'); + if (completion.isCompleted) { + logger?.finer('Completion already called. Ignoring.'); + return; + } + if (error != null) { + completion.completeError(error); + return; + } + if (uri == null) { + completion.completeError( + const NativeAuthException('Completed with invalid redirect URL'), + ); + return; + } + completion.complete(uri); + }); + final session = callbackScheme.session( + url: url, + completionHandler: completionHandler, + ); + _currentCompletionHandler = completionHandler; + session.prefersEphemeralWebBrowserSession = true; + session.presentationContextProvider = _presentationContextProvider; + if (!session.start()) { + logger?.severe('Failed to start ASWebAuthenticationSession'); + _cleanUp(); + throw const NativeAuthException( + 'Failed to start ASWebAuthenticationSession', + ); + } + logger?.fine('Started ASWebAuthenticationSession'); + completion.future.whenComplete(_cleanUp).ignore(); + return NativeAuthCallbackSessionImpl( + NativeAuthCallbackSessionImpl.nextId(), + completion, + session.cancel, + ); + } + + @override + Future performAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) async { + final completion = startAuthorizationRedirect( + uri: uri, + callbackScheme: callbackScheme, + ); + return completion.redirectUri; + } +} + +extension on CallbackScheme { + ASWebAuthenticationSession session({ + required objc.NSURL url, + required ObjCBlock_ffiVoid_NSURL_NSError completionHandler, + }) { + final session = ASWebAuthenticationSession.alloc(); + switch (this) { + case CallbackSchemeCustom(:final scheme): + return session.initWithURL_callbackURLScheme_completionHandler_( + url, + scheme.toNSString(), + completionHandler, + ); + case CallbackSchemeLocalhost(): + throw ArgumentError.value( + this, + 'callbackScheme', + 'Localhost scheme is not supported on iOS', + ); + case CallbackSchemeHttps(:final host, :final path): + return session.initWithURL_callback_completionHandler_( + url, + ASWebAuthenticationSessionCallback.callbackWithHTTPSHost_path_( + host.toNSString(), + path.toNSString(), + ), + completionHandler, + ); + } + } +} diff --git a/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.macos.dart b/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.macos.dart new file mode 100644 index 0000000..98186e7 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/lib/src/platform/native_auth.macos.dart @@ -0,0 +1,156 @@ +import 'dart:async'; +import 'dart:ffi'; + +import 'package:native_auth_flutter/native_auth_flutter.dart'; +import 'package:native_auth_flutter/src/model/callback_session.dart'; +import 'package:native_auth_flutter/src/native/macos/authentication_services.ffi.dart'; +import 'package:native_auth_flutter/src/platform/native_auth.desktop.dart'; +import 'package:objective_c/objective_c.dart' as objc; + +final class NativeAuthMacOs extends NativeAuthDesktop { + NativeAuthMacOs({super.logger}); + + // Hold strong references to the callbacks to prevent them from being + // garbage collected. + ObjCBlock_ffiVoid_NSURL_NSError? _currentCompletionHandler; + late final _presentationContextProvider = + ASWebAuthenticationPresentationContextProviding.implement( + presentationAnchorForWebAuthenticationSession_: (session) { + final windowsId = NSApplication.getSharedApplication().windows; + if (!objc.NSArray.isInstance(windowsId)) { + logger?.severe('Failed to get application windows'); + session.cancel(); + return NSWindow.castFromPointer(nullptr); + } + final windows = objc.NSArray.castFrom(windowsId); + NSWindow? keyWindow; + for (var i = 0; i < windows.count; i++) { + final windowId = windows.objectAtIndex_(i); + if (!NSWindow.isInstance(windowId)) { + continue; + } + final window = NSWindow.castFrom(windowId); + if (window.keyWindow || keyWindow == null) { + keyWindow = window; + } + } + if (keyWindow == null) { + logger?.severe('Failed to get key window'); + session.cancel(); + return NSWindow.castFromPointer(nullptr); + } + return keyWindow; + }, + ); + + void _cleanUp() { + _currentCompletionHandler?.release(); + _currentCompletionHandler = null; + } + + @override + NativeAuthCallbackSession startAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) { + if (callbackScheme is CallbackSchemeLocalhost) { + return super.startAuthorizationRedirect( + uri: uri, + callbackScheme: callbackScheme, + ); + } + final url = objc.NSURL.URLWithString_(uri.toString().toNSString()); + if (url == null) { + logger?.severe('Invalid URL: $uri'); + throw NativeAuthException('Invalid URL: $uri'); + } + final completion = Completer(); + final completionHandler = + ObjCBlock_ffiVoid_NSURL_NSError.listener((url, error) { + final uri = switch (url?.absoluteString?.toString()) { + final url? => Uri.tryParse(url), + _ => null, + }; + logger?.fine('Redirect completion: url=$uri, error=$error'); + if (completion.isCompleted) { + logger?.finer('Completion already called. Ignoring.'); + return; + } + if (error != null) { + completion.completeError(error); + return; + } + if (uri == null) { + completion.completeError( + const NativeAuthException('Completed with invalid redirect URL'), + ); + return; + } + completion.complete(uri); + }); + final session = callbackScheme.session( + url: url, + completionHandler: completionHandler, + ); + _currentCompletionHandler = completionHandler; + session.prefersEphemeralWebBrowserSession = true; + session.presentationContextProvider = _presentationContextProvider; + if (!session.start()) { + logger?.severe('Failed to start ASWebAuthenticationSession'); + _cleanUp(); + throw const NativeAuthException( + 'Failed to start ASWebAuthenticationSession', + ); + } + logger?.fine('Started ASWebAuthenticationSession'); + completion.future.whenComplete(_cleanUp).ignore(); + return NativeAuthCallbackSessionImpl( + NativeAuthCallbackSessionImpl.nextId(), + completion, + session.cancel, + ); + } + + @override + Future performAuthorizationRedirect({ + required Uri uri, + required CallbackScheme callbackScheme, + }) async { + final completion = startAuthorizationRedirect( + uri: uri, + callbackScheme: callbackScheme, + ); + return completion.redirectUri; + } +} + +extension on CallbackScheme { + ASWebAuthenticationSession session({ + required objc.NSURL url, + required ObjCBlock_ffiVoid_NSURL_NSError completionHandler, + }) { + final session = ASWebAuthenticationSession.alloc(); + switch (this) { + case CallbackSchemeLocalhost(): + // Should have been handled above. + throw UnsupportedError( + 'Localhost redirect scheme is not supported on this platform', + ); + case CallbackSchemeCustom(:final scheme): + return session.initWithURL_callbackURLScheme_completionHandler_( + url, + scheme.toNSString(), + completionHandler, + ); + case CallbackSchemeHttps(:final host, :final path): + return session.initWithURL_callback_completionHandler_( + url, + ASWebAuthenticationSessionCallback.callbackWithHTTPSHost_path_( + host.toNSString(), + path.toNSString(), + ), + completionHandler, + ); + } + } +} diff --git a/packages/native/auth/native_auth_flutter/macos/Classes/AuthenticationServices.ffi.m b/packages/native/auth/native_auth_flutter/macos/Classes/AuthenticationServices.ffi.m new file mode 100644 index 0000000..1f5e251 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/macos/Classes/AuthenticationServices.ffi.m @@ -0,0 +1,162 @@ +#include + +#import +#import +#import +#import +#import +#import +#import + +typedef void (^ListenerBlock)(NSEvent* ); +ListenerBlock wrapListenerBlock_ObjCBlock_ffiVoid_NSEvent(ListenerBlock block) { + ListenerBlock wrapper = [^void(NSEvent* arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock1)(NSError* ); +ListenerBlock1 wrapListenerBlock_ObjCBlock_ffiVoid_NSError(ListenerBlock1 block) { + ListenerBlock1 wrapper = [^void(NSError* arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock2)(NSEvent* , BOOL * ); +ListenerBlock2 wrapListenerBlock_ObjCBlock_ffiVoid_NSEvent_bool(ListenerBlock2 block) { + ListenerBlock2 wrapper = [^void(NSEvent* arg0, BOOL * arg1) { + block([arg0 retain], arg1); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock3)(NSWindow* , BOOL * ); +ListenerBlock3 wrapListenerBlock_ObjCBlock_ffiVoid_NSWindow_bool(ListenerBlock3 block) { + ListenerBlock3 wrapper = [^void(NSWindow* arg0, BOOL * arg1) { + block([arg0 retain], arg1); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock4)(void * , NSApplication* , id ); +ListenerBlock4 wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_objcObjCObject(ListenerBlock4 block) { + ListenerBlock4 wrapper = [^void(void * arg0, NSApplication* arg1, id arg2) { + block(arg0, [arg1 retain], [arg2 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock5)(void * , NSApplication* , NSData* ); +ListenerBlock5 wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSData(ListenerBlock5 block) { + ListenerBlock5 wrapper = [^void(void * arg0, NSApplication* arg1, NSData* arg2) { + block(arg0, [arg1 retain], [arg2 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock6)(void * , NSApplication* , NSError* ); +ListenerBlock6 wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSError(ListenerBlock6 block) { + ListenerBlock6 wrapper = [^void(void * arg0, NSApplication* arg1, NSError* arg2) { + block(arg0, [arg1 retain], [arg2 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock7)(void * , NSApplication* , NSDictionary* ); +ListenerBlock7 wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSDictionary(ListenerBlock7 block) { + ListenerBlock7 wrapper = [^void(void * arg0, NSApplication* arg1, NSDictionary* arg2) { + block(arg0, [arg1 retain], [arg2 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock8)(void * , NSApplication* , NSCoder* ); +ListenerBlock8 wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSCoder(ListenerBlock8 block) { + ListenerBlock8 wrapper = [^void(void * arg0, NSApplication* arg1, NSCoder* arg2) { + block(arg0, [arg1 retain], [arg2 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock9)(NSInputStream* , NSOutputStream* , NSError* ); +ListenerBlock9 wrapListenerBlock_ObjCBlock_ffiVoid_NSInputStream_NSOutputStream_NSError(ListenerBlock9 block) { + ListenerBlock9 wrapper = [^void(NSInputStream* arg0, NSOutputStream* arg1, NSError* arg2) { + block([arg0 retain], [arg1 retain], [arg2 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock10)(NSTimer* ); +ListenerBlock10 wrapListenerBlock_ObjCBlock_ffiVoid_NSTimer(ListenerBlock10 block) { + ListenerBlock10 wrapper = [^void(NSTimer* arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock11)(NSArray* ); +ListenerBlock11 wrapListenerBlock_ObjCBlock_ffiVoid_NSArray(ListenerBlock11 block) { + ListenerBlock11 wrapper = [^void(NSArray* arg0) { + block([arg0 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock12)(void * , NSApplication* , NSString* , NSError* ); +ListenerBlock12 wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSString_NSError(ListenerBlock12 block) { + ListenerBlock12 wrapper = [^void(void * arg0, NSApplication* arg1, NSString* arg2, NSError* arg3) { + block(arg0, [arg1 retain], [arg2 retain], [arg3 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock13)(void * , NSApplication* , NSUserActivity* ); +ListenerBlock13 wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_NSUserActivity(ListenerBlock13 block) { + ListenerBlock13 wrapper = [^void(void * arg0, NSApplication* arg1, NSUserActivity* arg2) { + block(arg0, [arg1 retain], [arg2 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock14)(void * , NSApplication* , CKShareMetadata* ); +ListenerBlock14 wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSApplication_CKShareMetadata(ListenerBlock14 block) { + ListenerBlock14 wrapper = [^void(void * arg0, NSApplication* arg1, CKShareMetadata* arg2) { + block(arg0, [arg1 retain], [arg2 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock15)(void * , NSNotification* ); +ListenerBlock15 wrapListenerBlock_ObjCBlock_ffiVoid_ffiVoid_NSNotification(ListenerBlock15 block) { + ListenerBlock15 wrapper = [^void(void * arg0, NSNotification* arg1) { + block(arg0, [arg1 retain]); + } copy]; + [block release]; + return wrapper; +} + +typedef void (^ListenerBlock16)(NSURL* , NSError* ); +ListenerBlock16 wrapListenerBlock_ObjCBlock_ffiVoid_NSURL_NSError(ListenerBlock16 block) { + ListenerBlock16 wrapper = [^void(NSURL* arg0, NSError* arg1) { + block([arg0 retain], [arg1 retain]); + } copy]; + [block release]; + return wrapper; +} diff --git a/packages/native/auth/native_auth_flutter/macos/native_auth_flutter.podspec b/packages/native/auth/native_auth_flutter/macos/native_auth_flutter.podspec new file mode 100644 index 0000000..e9fb939 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/macos/native_auth_flutter.podspec @@ -0,0 +1,22 @@ +Pod::Spec.new do |s| + s.name = 'native_auth_flutter' + s.version = '0.0.1' + s.summary = 'Native support for package:native_auth_flutter' + s.description = <<-DESC +Wraps ASWebAuthenticationSession for macOS. + DESC + s.homepage = 'https://celest.dev' + s.license = { :file => '../LICENSE' } + s.author = { 'Celest' => 'contact@celest.dev' } + + s.swift_version = '5.0' + s.platform = :osx, '10.15' + s.dependency 'FlutterMacOS' + + s.source = { :path => '.' } + s.source_files = 'Classes/**/*' + s.compiler_flags = ['-fno-objc-arc'] + s.frameworks = 'AuthenticationServices', 'AppKit' + + s.pod_target_xcconfig = { 'DEFINES_MODULE' => 'YES' } +end diff --git a/packages/native/auth/native_auth_flutter/pubspec.yaml b/packages/native/auth/native_auth_flutter/pubspec.yaml new file mode 100644 index 0000000..f3f94c4 --- /dev/null +++ b/packages/native/auth/native_auth_flutter/pubspec.yaml @@ -0,0 +1,40 @@ +name: native_auth_flutter +description: Native bindings for platform-specific authentication APIs like ASWebAuthenticationSession and Chrome Custom Tabs. +version: 0.1.0 +publish_to: none + +environment: + sdk: ^3.3.0 + flutter: '>=3.19.0' + +dependencies: + async: ^2.11.0 + collection: ^1.18.0 + ffi: ^2.1.3 + flutter: + sdk: flutter + jni: '>=0.9.0 <0.11.0' + logging: ^1.2.0 + meta: ^1.15.0 + objective_c: ^1.1.0 + path: ^1.9.0 + plugin_platform_interface: ^2.0.0 + stream_transform: ^2.1.0 + web: ^1.0.0 + +dev_dependencies: + ffigen: ^13.0.0 + flutter_test: + sdk: flutter + flutter_lints: ^4.0.0 + jnigen: ^0.10.0 + +flutter: + plugin: + platforms: + android: + ffiPlugin: true + ios: + ffiPlugin: true + macos: + ffiPlugin: true