import type { NobjcObject } from "objc-js";
import type { _NSArray } from "../Foundation/NSArray.js";
import type { _NSData } from "../Foundation/NSData.js";
import type { _NSError } from "../Foundation/NSError.js";
import type { _NSObject } from "../Foundation/NSObject.js";
import type { _NSSet } from "../Foundation/NSSet.js";
import type { _NSString } from "../Foundation/NSString.js";
import type { _CLBeaconIdentityConstraint } from "./CLBeaconIdentityConstraint.js";
import type { _CLBeaconRegion } from "./CLBeaconRegion.js";
import type { _CLHeading } from "./CLHeading.js";
import type { _CLLocationManagerDelegate } from "./CLLocationManagerDelegate.js";
import type { _CLRegion } from "./CLRegion.js";
import type { CLAccuracyAuthorization } from "./CLAccuracyAuthorization.js";
import type { CLActivityType } from "./CLActivityType.js";
import type { CLAuthorizationStatus } from "./CLAuthorizationStatus.js";
import type { CLDeviceOrientation } from "./CLDeviceOrientation.js";
export declare class _CLLocationManager extends _NSObject {
    static alloc(): _CLLocationManager;
    static new(): _CLLocationManager;
    init(): _CLLocationManager;
    /**
     * locationServicesEnabled Discussion: Determines whether the user has location services enabled. If NO, and you proceed to call other CoreLocation API, user will be prompted with the warning dialog. You may want to check this property and use location services only when explicitly requested by the user.
     */
    static locationServicesEnabled(): boolean;
    /**
     * headingAvailable Discussion: Returns YES if the device supports the heading service, otherwise NO.
     */
    static headingAvailable(): boolean;
    /**
     * significantLocationChangeMonitoringAvailable Discussion: Returns YES if the device supports significant location change monitoring, otherwise NO.
     */
    static significantLocationChangeMonitoringAvailable(): boolean;
    /**
     * isMonitoringAvailableForClass: Discussion: Determines whether the device supports monitoring for the specified type of region. If NO, all attempts to monitor the specified type of region will fail.
     */
    static isMonitoringAvailableForClass$(regionClass: NobjcObject): boolean;
    /**
     * regionMonitoringAvailable Discussion: Deprecated. Use +isMonitoringAvailableForClass: instead.
     * @deprecated +isMonitoringAvailableForClass:
     */
    static regionMonitoringAvailable(): boolean;
    /**
     * regionMonitoringEnabled Discussion: Deprecated. Use +isMonitoringAvailableForClass: and -authorizationStatus instead.
     * @deprecated Use +isMonitoringAvailableForClass: and -authorizationStatus instead
     */
    static regionMonitoringEnabled(): boolean;
    /**
     * isRangingAvailable Discussion: Determines whether the device supports ranging. If NO, all attempts to range beacons will fail.
     */
    static isRangingAvailable(): boolean;
    /**
     * authorizationStatus Discussion: Deprecated. Use the instance property authorizationStatus instead.
     * @deprecated -authorizationStatus
     */
    static authorizationStatus(): CLAuthorizationStatus;
    /**
     * deferredLocationUpdatesAvailable Discussion: Returns YES if the device supports deferred location updates, otherwise NO.
     * @deprecated You can remove calls to this method
     */
    static deferredLocationUpdatesAvailable(): boolean;
    /**
     * requestWhenInUseAuthorization Discussion: When -authorizationStatus == kCLAuthorizationStatusNotDetermined, calling this method will trigger a prompt to request "when-in-use" authorization from the user. Any authorization change as a result of the prompt will be reflected via the usual delegate callback: -locationManager:didChangeAuthorizationStatus:. If possible, perform this call in response to direct user request for a location-based service so that the reason for the prompt will be clear, and the utility of a one-time grant is maximized. If received, "when-in-use" authorization grants access to the user's location via any CoreLocation API as long as your app is being actively used by the user. Typically this means your app must be in the foreground. If you start a Continuous Background Location session (see -allowsBackgroundLocationUpdates), then CoreLocation will maintain visibility for your app as it enters the background. This will enable your app to continue receiving location information even as another app enters the foreground. Your app will remain visible in this way until location updates are stopped or your app is killed by the user. When -authorizationStatus != kCLAuthorizationStatusNotDetermined, (ie generally after the first call) this method will do nothing. If your app is not currently in use, this method will do nothing. The NSLocationWhenInUseUsageDescription key must be specified in your Info.plist; otherwise, this method will do nothing, as your app will be assumed not to support WhenInUse authorization.
     */
    requestWhenInUseAuthorization(): void;
    /**
     * requestAlwaysAuthorization Discussion: When -authorizationStatus == kCLAuthorizationStatusNotDetermined, calling this method will start the process of requesting "always" authorization from the user. Any authorization change as a result of the prompt will be reflected via the usual delegate callback: -locationManager:didChangeAuthorizationStatus:. If possible, perform this call in response to direct user request for a location-based service so that the reason for the prompt will be clear, and the utility of a one-time grant is maximized. If received, "always" authorization grants access to the user's location via any CLLocationManager API. In addition, monitoring APIs may launch your app into the background when they detect an event. Even if killed by the user, launch events triggered by monitoring APIs will cause a relaunch. "Always" authorization presents a significant risk to user privacy, and as such requesting it is discouraged unless background launch behavior is genuinely required. Do not call +requestAlwaysAuthorization unless you think users will thank you for doing so. An application which currently has "when-in-use" authorization and has never before requested "always" authorization may use this method to request "always" authorization one time only. Otherwise, if -authorizationStatus != kCLAuthorizationStatusNotDetermined, (ie generally after the first call) this method will do nothing. If your app is not currently in use, this method will do nothing. Both the NSLocationAlwaysAndWhenInUseUsageDescription and NSLocationWhenInUseUsageDescription keys must be specified in your Info.plist; otherwise, this method will do nothing, as your app will be assumed not to support Always authorization.
     */
    requestAlwaysAuthorization(): void;
    /**
     * requestTemporaryFullAccuracyAuthorizationWithPurposeKey:completion: Discussion: If your app doesn't have permission to access accurate location (see -accuracyAuthorization), you can use this method to request temporary access to accurate location. This access will expire automatically, but it won't expire while the user is still engaged with your app. So, for example, while your app is in the foreground your app will retain the temporary access it was granted. Similarly, if your app starts a Continuous Background Location session with the background location indicator enabled (see -showsBackgroundLocationIndicator), your access to accurate location will remain as long as the background location indicator remains enabled. This allows your app to provide session-oriented experiences which require accurate location (e.g. fitness or navigation), even if the user has decided not to grant your app persistent access to accurate location. When CoreLocation prepares the prompt for display, it will look at the NSLocationTemporaryUsageDescriptionDictionary key in your Info.plist. The value should be a dictionary containing usage descriptions. The purposeKey you provide to this method must correspond to an entry in that dictionary. To retrieve a localized string, CoreLocation will load your InfoPlist.strings file and try to look up a string using the purposeKey you provided. If that fails, CoreLocation will use the content provided in your Info.plist. For example, suppose your Info.plist contains the following. <key >NSLocationTemporaryUsageDescriptionDictionary </key > <dict > <key >ExampleUsageDescription </key > <string >This app needs accurate location so it can verify that you're in a supported region. </string > <key >AnotherUsageDescription </key > <string >This app needs accurate location so it can show you relevant results. </string > </dict > In this case, you would be able to provide either "ExampleUsageDescription" or "AnotherUsageDescription" for the purposeKey argument. Passing any other string would result in the prompt not being displayed. To localize these usage descriptions, you would add entries for "ExampleUsageDescription" and "AnotherUsageDescription" to your InfoPlist.strings file. CoreLocation may decide against showing the user a prompt. For example, if your app already has access to accurate location or it is currently in the background. When that happens, your completion block will be called with an appropriate NSError. If the user responded to the prompt, your completion block will be called with a nil error. At that point, you may query the state of your CLLocationManager to see if you have been granted accurate access. The completion block will be called in the same threading context where delegate callbacks occur. That is, it will be called on the runloop where the CLLocationManager was originally initialized.
     */
    requestTemporaryFullAccuracyAuthorizationWithPurposeKey$completion$(purposeKey: _NSString, completion: ((arg0: _NSError) => void) | null): void;
    /**
     * requestTemporaryFullAccuracyAuthorizationWithPurposeKey: Discussion: This is a variant of requestTemporaryAccurateLocationAuthorizationWithPurposeKey:completion: which doesn't take a completion block. This is equivalent to passing in a nil completion block.
     */
    requestTemporaryFullAccuracyAuthorizationWithPurposeKey$(purposeKey: _NSString): void;
    /** startUpdatingLocation Discussion: Start updating locations. */
    startUpdatingLocation(): void;
    /** stopUpdatingLocation Discussion: Stop updating locations. */
    stopUpdatingLocation(): void;
    /**
     * requestLocation Discussion: Request a single location update. The service will attempt to determine location with accuracy according to the desiredAccuracy property. The location update will be delivered via the standard delegate callback, i.e. locationManager:didUpdateLocations: If the best available location has lower accuracy, then it will be delivered via the standard delegate callback after timeout. If no location can be determined, the locationManager:didFailWithError: delegate callback will be delivered with error location unknown. There can only be one outstanding location request and this method can not be used concurrently with startUpdatingLocation or allowDeferredLocationUpdates. Calling either of those methods will immediately cancel the location request. The method stopUpdatingLocation can be used to explicitly cancel the request.
     */
    requestLocation(): void;
    /** startUpdatingHeading Discussion: Start updating heading. */
    startUpdatingHeading(): void;
    /** stopUpdatingHeading Discussion: Stop updating heading. */
    stopUpdatingHeading(): void;
    /**
     * dismissHeadingCalibrationDisplay Discussion: Dismiss the heading calibration immediately.
     */
    dismissHeadingCalibrationDisplay(): void;
    /**
     * startMonitoringSignificantLocationChanges Discussion: Start monitoring significant location changes. The behavior of this service is not affected by the desiredAccuracy or distanceFilter properties. Locations will be delivered through the same delegate callback as the standard location service.
     */
    startMonitoringSignificantLocationChanges(): void;
    /**
     * stopMonitoringSignificantLocationChanges Discussion: Stop monitoring significant location changes.
     */
    stopMonitoringSignificantLocationChanges(): void;
    /**
     * startMonitoringLocationPushes Discussion: Request an Apple Push Notification service token to be used to send location pushes. Incoming location pushes launch the app's Location Push Service Extension. Requires the com.apple.developer.location.push entitlement.
     */
    startMonitoringLocationPushesWithCompletion$(completion: ((token: _NSData, arg1: _NSError) => void) | null): void;
    /** stopMonitoringLocationPushes Discussion: Stop monitoring for location pushes. */
    stopMonitoringLocationPushes(): void;
    /**
     * startMonitoringForRegion:desiredAccuracy: Discussion: Start monitoring the specified region. desiredAccuracy represents the distance past the border of the region at which the application would like to be notified that the region border has been crossed. This is useful to prevent repeated notifications when the user is on the border of the region. This value will be honored on a best-effort basis, and may not be respected if desiredAccuracy is large with respect to the size of the region, or if the device is not capable of providing the precision desired. If a region of the same type with the same identifier is already being monitored for this application, it will be removed from monitoring. This is done asynchronously and may not be immediately reflected in monitoredRegions.
     * @deprecated -startMonitoringForRegion:
     */
    startMonitoringForRegion$desiredAccuracy$(region: _CLRegion, accuracy: number): void;
    /**
     * stopMonitoringForRegion: Discussion: Stop monitoring the specified region. It is valid to call stopMonitoringForRegion: for a region that was registered for monitoring with a different location manager object, during this or previous launches of your application. This is done asynchronously and may not be immediately reflected in monitoredRegions.
     * @deprecated Use CLMonitor to start or stop monitoring constraint
     */
    stopMonitoringForRegion$(region: _CLRegion): void;
    /**
     * startMonitoringForRegion: Discussion: Start monitoring the specified region. If a region of the same type with the same identifier is already being monitored for this application, it will be removed from monitoring. For circular regions, the region monitoring service will prioritize regions by their size, favoring smaller regions over larger regions. This is done asynchronously and may not be immediately reflected in monitoredRegions.
     * @deprecated Use CLMonitor to start or stop monitoring constraint
     */
    startMonitoringForRegion$(region: _CLRegion): void;
    /**
     * requestStateForRegion: Discussion: Asynchronously retrieve the cached state of the specified region. The state is returned to the delegate via locationManager:didDetermineState:forRegion:.
     * @deprecated Use CLMonitor to track and query the state for monitored constraints
     */
    requestStateForRegion$(region: _CLRegion): void;
    /**
     * startRangingBeaconsInRegion: Discussion: Start calculating ranges for beacons in the specified region.
     * @deprecated Use -startRangingBeaconsSatisfyingConstraint:
     */
    startRangingBeaconsInRegion$(region: _CLBeaconRegion): void;
    /**
     * stopRangingBeaconsInRegion: Discussion: Stop calculating ranges for the specified region.
     * @deprecated Use -stopRangingBeaconsSatisfyingConstraint:
     */
    stopRangingBeaconsInRegion$(region: _CLBeaconRegion): void;
    /**
     * startRangingBeaconsSatisfyingConstraint: Discussion: Start producing ranging measurements for beacons that satisfy the provided constraint. Ranging will continue until you pass an equivalent constraint to stopRangingBeaconsSatisfyingConstraint:.
     */
    startRangingBeaconsSatisfyingConstraint$(constraint: _CLBeaconIdentityConstraint): void;
    /**
     * stopRangingBeaconsSatisfyingConstraint: Discussion: Stop an earlier beacon ranging request. See startRangingBeaconsSatisfyingConstraint:.
     */
    stopRangingBeaconsSatisfyingConstraint$(constraint: _CLBeaconIdentityConstraint): void;
    /**
     * allowDeferredLocationUpdatesUntilTraveled:timeout: Discussion: Indicate that the application will allow the location manager to defer location updates until an exit criterion is met. This may allow the device to enter a low-power state in which updates are held for later delivery. Once an exit condition is met, the location manager will continue normal updates until this method is invoked again. Exit conditions, distance and timeout, can be specified using the constants CLLocationDistanceMax and CLTimeIntervalMax, respectively, if you are trying to achieve an unlimited distance or timeout. The CLLocationManagerDelegate will continue to receive normal updates as long as the application remains in the foreground. While the process is in the background, the device may be able to enter a low-power state for portions of the specified distance and time interval. While in this state, locations will be coalesced for later delivery. Location updates will be deferred as much as is reasonable to save power. If another process is using location, the device may not enter a low-power state and instead updates will continue normally. Deferred updates may be interspersed with normal updates if the device exits and re-enters a low-power state. All location updates, including deferred updates, will be delivered via the delegate callback locationManager:didUpdateLocations: When deferred updates have ended, the manager will invoke the delegate callback locationManagerDidFinishDeferredUpdates:withError:. An error will be returned if the manager will not defer updates and the exit criteria have not been met.
     * @deprecated You can remove calls to this method
     */
    allowDeferredLocationUpdatesUntilTraveled$timeout$(distance: number, timeout: number): void;
    /**
     * disallowDeferredLocationUpdates Discussion: Disallow deferred location updates if previously enabled. Any outstanding updates will be sent and regular location updates will resume.
     * @deprecated You can remove calls to this method
     */
    disallowDeferredLocationUpdates(): void;
    /**
     * requestHistoricalLocationsWithPurposeKey:sampleCount:completionHandler: Discussion: Request asynchronous delivery of historical location information. If the app is currently configured correctly, historical locations are available, and this request is approved by the user via prompt, then the historical locations will be delivered to the completion handler. Otherwise, the completion handler will be invoked with an empty array. Historical location availability is subject to privacy limits and should never be assumed available. If historic location is not available, no prompt will be presented to the user, and the empty array will be returned. The sampleCount parameter may be used to limit the number of returned locations by decimation. Correct configuration requires the App to: - Have effective authorization to receive the user's current location. - Carry the required entitlement: com.apple.developer.corelocation.wilderness-safety - Have a NSLocationWildernessSafetyUsageDescriptionDictionary in its info.plist and related localized resources - Pass a key identifying a usage description string in that dictionary to be included in the prompt to the user if one is shown. The completion handler will receive a non-nil error object in the event of misconfiguration. Requires the com.apple.developer.corelocation.wilderness-safety entitlement.
     */
    requestHistoricalLocationsWithPurposeKey$sampleCount$completionHandler$(purposeKey: _NSString, sampleCount: number, handler: ((arg0: _NSArray, arg1: _NSError) => void) | null): void;
    /**
     * startMonitoringVisits Discussion: Begin monitoring for visits. All CLLLocationManagers allocated by your application, both current and future, will deliver detected visits to their delegates. This will continue until -stopMonitoringVisits is sent to any such CLLocationManager, even across application relaunch events. Detected visits are sent to the delegate's -locationManager:didVisit: method.
     */
    startMonitoringVisits(): void;
    /**
     * stopMonitoringVisits Discussion: Stop monitoring for visits. To resume visit monitoring, send -startMonitoringVisits. Note that stopping and starting are asynchronous operations and may not immediately reflect in delegate callback patterns.
     */
    stopMonitoringVisits(): void;
    /**
     * authorizationStatus Discussion: Returns the current authorization status of the calling application.
     */
    authorizationStatus(): CLAuthorizationStatus;
    /**
     * accuracyAuthorization Discussion: Returns information about the calling application's access to accurate location. See the documentation for CLAccuracyAuthorization for information about how to interpret the return value. Note that this property should generally be interpreted in the context of the authorizationStatus property. For example, if authorizationStatus == kCLAuthorizationStatusNotDetermined then accurate location information cannot be received even when accuracyAuthorization is CLAccuracyAuthorizationFullAccuracy.
     */
    accuracyAuthorization(): CLAccuracyAuthorization;
    /**
     * authorizedForWidgetUpdates Discussion: Returns true if widgets of the calling application may be eligible to receive location updates. If the calling application has authorizationStatus == kCLAuthorizationStatusAuthorizedWhenInUse, and authorizedForWidgetUpdates == YES, then widgets will be able to get location updates if called upon to refresh within a few minutes of having been seen. If the calling application has authorizationStatus == kCLAuthorizationStatusAuthorizedAlways, then authorizedForWidgetUpdates will always be YES.
     */
    authorizedForWidgetUpdates(): boolean;
    delegate(): _CLLocationManagerDelegate | null;
    setDelegate$(value: _CLLocationManagerDelegate | null): void;
    /**
     * locationServicesEnabled Discussion: Deprecated. Use +locationServicesEnabled instead.
     * @deprecated +locationServicesEnabled
     */
    locationServicesEnabled(): boolean;
    /**
     * purpose Discussion: Allows the application to specify what location will be used for in their app. This will be displayed along with the standard Location permissions dialogs. This property will need to be set prior to calling startUpdatingLocation. Deprecated. Set the purpose string in Info.plist using key NSLocationUsageDescription.
     * @deprecated Set the purpose string in Info.plist using key NSLocationUsageDescription
     */
    purpose(): _NSString | null;
    setPurpose$(value: _NSString | null): void;
    /**
     * activityType Discussion: Specifies the type of user activity. Currently affects behavior such as the determination of when location updates may be automatically paused. By default, CLActivityTypeOther is used.
     */
    activityType(): CLActivityType;
    setActivityType$(value: CLActivityType): void;
    /**
     * distanceFilter Discussion: Specifies the minimum update distance in meters. Client will not be notified of movements of less than the stated value, unless the accuracy has improved. Pass in kCLDistanceFilterNone to be notified of all movements. By default, kCLDistanceFilterNone is used.
     */
    distanceFilter(): number;
    setDistanceFilter$(value: number): void;
    /**
     * desiredAccuracy Discussion: The desired location accuracy. The location service will try its best to achieve your desired accuracy. However, it is not guaranteed. To optimize power performance, be sure to specify an appropriate accuracy for your usage scenario (eg, use a large accuracy value when only a coarse location is needed). Use kCLLocationAccuracyBest to achieve the best possible accuracy. Use kCLLocationAccuracyBestForNavigation for navigation. The default value varies by platform.
     */
    desiredAccuracy(): number;
    setDesiredAccuracy$(value: number): void;
    /**
     * pausesLocationUpdatesAutomatically Discussion: Specifies that location updates may automatically be paused when possible. By default, this is YES for applications linked against iOS 6.0 or later.
     */
    pausesLocationUpdatesAutomatically(): boolean;
    setPausesLocationUpdatesAutomatically$(value: boolean): void;
    /**
     * allowsBackgroundLocationUpdates Discussion: By default, this is NO for applications linked against iOS 9.0 or later, regardless of minimum deployment target. With UIBackgroundModes set to include "location" in Info.plist, you must also set this property to YES at runtime whenever calling -startUpdatingLocation with the intent to continue in the background. Setting this property to YES when UIBackgroundModes does not include "location" is a fatal error. Resetting this property to NO is equivalent to omitting "location" from the UIBackgroundModes value. Access to location is still permitted whenever the application is running (ie not suspended), and has sufficient authorization (ie it has WhenInUse authorization and is in use, or it has Always authorization). However, the app will still be subject to the usual task suspension rules. See -requestWhenInUseAuthorization and -requestAlwaysAuthorization for more details on possible authorization values.
     */
    allowsBackgroundLocationUpdates(): boolean;
    setAllowsBackgroundLocationUpdates$(value: boolean): void;
    /**
     * showsBackgroundLocationIndicator Discussion: Specifies that an indicator be shown when the app makes use of continuous background location updates. Starting continuous background location updates requires the app to set UIBackgroundModes to include "location" and to set the property allowsBackgroundLocationUpdates to YES before calling -startUpdatingLocation with the intent to continue in the background. Note that this property only applies to apps with Always authorization. For apps with WhenInUse authorization, the indicator is always shown when using continuous background location updates in order to maintain user visibility and that the app is still in use. The default value of this property is NO.
     */
    showsBackgroundLocationIndicator(): boolean;
    setShowsBackgroundLocationIndicator$(value: boolean): void;
    /**
     * location Discussion: The last location received. Will be nil until a location has been received.
     */
    location(): NobjcObject | null;
    /**
     * headingAvailable Discussion: Deprecated. Use +headingAvailable instead.
     * @deprecated +headingAvailable
     */
    headingAvailable(): boolean;
    /**
     * headingFilter Discussion: Specifies the minimum amount of change in degrees needed for a heading service update. Client will not be notified of updates less than the stated filter value. Pass in kCLHeadingFilterNone to be notified of all updates. By default, 1 degree is used.
     */
    headingFilter(): number;
    setHeadingFilter$(value: number): void;
    /**
     * headingOrientation Discussion: Specifies a physical device orientation from which heading calculation should be referenced. By default, CLDeviceOrientationPortrait is used. CLDeviceOrientationUnknown, CLDeviceOrientationFaceUp, and CLDeviceOrientationFaceDown are ignored.
     */
    headingOrientation(): CLDeviceOrientation;
    setHeadingOrientation$(value: CLDeviceOrientation): void;
    /**
     * heading Discussion: Returns the latest heading update received, or nil if none is available.
     */
    heading(): _CLHeading | null;
    /**
     * maximumRegionMonitoringDistance Discussion: the maximum region size, in terms of a distance from a central point, that the framework can support. Attempts to register a region larger than this will generate a kCLErrorRegionMonitoringFailure. This value may vary based on the hardware features of the device, as well as on dynamically changing resource constraints.
     */
    maximumRegionMonitoringDistance(): number;
    /**
     * monitoredRegions Discussion: Retrieve a set of objects for the regions that are currently being monitored. If any location manager has been instructed to monitor a region, during this or previous launches of your application, it will be present in this set.
     */
    monitoredRegions(): _NSSet;
    /**
     * rangedRegions Discussion: Retrieve a set of objects representing the regions for which this location manager is actively providing ranging.
     * @deprecated Use -rangedBeaconConstraints
     */
    rangedRegions(): _NSSet;
    /**
     * rangedBeaconConstraints Discussion: Retrieve a set of beacon constraints for which this location manager is actively providing ranging.
     */
    rangedBeaconConstraints(): _NSSet;
}
