TriceKit.ApiDefinition.cs

using System;
using CoreBluetooth;
using CoreGraphics;
using CoreLocation;
using Foundation;
using ObjCRuntime;
using UIKit;

namespace TriceKit
{
	// @interface TriceSettings : NSObject
	[BaseType (typeof(NSObject))]
	interface TriceSettings
	{
		// +(instancetype)sharedInstance;
		[Static]
		[Export ("sharedInstance")]
		TriceSettings SharedInstance ();

		// @property (copy, nonatomic) NSString * username;
		[Export ("username")]
		string Username { get; set; }

		// @property (copy, nonatomic) NSString * apiKey;
		[Export ("apiKey")]
		string ApiKey { get; set; }

		// @property (assign, nonatomic) BOOL debugEnabled;
		[Export ("debugEnabled")]
		bool DebugEnabled { get; set; }

		// @property (assign, nonatomic) BOOL useProductionServer;
		[Export ("useProductionServer")]
		bool UseProductionServer { get; set; }

		// @property (copy, nonatomic) void (^localNotificationConfigurationBlock)(UILocalNotification *);
		[Export ("localNotificationConfigurationBlock", ArgumentSemantic.Copy)]
		Action<UILocalNotification> LocalNotificationConfigurationBlock { get; set; }
	}

	[Verify (ConstantsInterfaceAssociation)]
	partial interface Constants
	{
		// extern NSString *const TriceColourKeyPrimary;
		[Field ("TriceColourKeyPrimary")]
		NSString TriceColourKeyPrimary { get; }

		// extern NSString *const TriceColourKeySecondary;
		[Field ("TriceColourKeySecondary")]
		NSString TriceColourKeySecondary { get; }

		// extern NSString *const TriceColourKeyElements;
		[Field ("TriceColourKeyElements")]
		NSString TriceColourKeyElements { get; }

		// extern NSString *const TriceFontKeyPrimary;
		[Field ("TriceFontKeyPrimary")]
		NSString TriceFontKeyPrimary { get; }

		// extern NSString *const TriceFontKeySecondary;
		[Field ("TriceFontKeySecondary")]
		NSString TriceFontKeySecondary { get; }
	}

	// @interface TriceStyleManager : NSObject
	[BaseType (typeof(NSObject))]
	interface TriceStyleManager
	{
		// +(void)setFontScale:(CGFloat)fontScale;
		[Static]
		[Export ("setFontScale:")]
		void SetFontScale (nfloat fontScale);

		// +(void)setFonts:(NSDictionary *)fonts;
		[Static]
		[Export ("setFonts:")]
		void SetFonts (NSDictionary fonts);

		// +(void)setColours:(NSDictionary *)colours;
		[Static]
		[Export ("setColours:")]
		void SetColours (NSDictionary colours);

		// +(UIColor *)colourForKey:(NSString *)key;
		[Static]
		[Export ("colourForKey:")]
		UIColor ColourForKey (string key);

		// +(UIFont *)fontForKey:(NSString *)key;
		[Static]
		[Export ("fontForKey:")]
		UIFont FontForKey (string key);

		// +(UIFont *)fontForKey:(NSString *)key size:(CGFloat)size;
		[Static]
		[Export ("fontForKey:size:")]
		UIFont FontForKey (string key, nfloat size);
	}

	// @interface TriceObjectDescriptor : NSObject
	[BaseType (typeof(NSObject))]
	interface TriceObjectDescriptor
	{
		// +(instancetype)descriptorWithUid:(NSString *)uid;
		[Static]
		[Export ("descriptorWithUid:")]
		TriceObjectDescriptor DescriptorWithUid (string uid);

		// +(instancetype)descriptorWithKey:(NSString *)key passingTest:(BOOL (^)(id))test;
		[Static]
		[Export ("descriptorWithKey:passingTest:")]
		TriceObjectDescriptor DescriptorWithKey (string key, Func<NSObject, bool> test);

		// +(instancetype)descriptorWithValue:(BOOL)value;
		[Static]
		[Export ("descriptorWithValue:")]
		TriceObjectDescriptor DescriptorWithValue (bool value);

		// -(BOOL)evaluateWithObject:(id)object;
		[Export ("evaluateWithObject:")]
		bool EvaluateWithObject (NSObject @object);
	}

	// @interface MTLModel : NSObject <NSCopying>
	[BaseType (typeof(NSObject))]
	interface MTLModel : INSCopying
	{
		// +(instancetype)modelWithDictionary:(NSDictionary *)dictionaryValue error:(NSError **)error;
		[Static]
		[Export ("modelWithDictionary:error:")]
		MTLModel ModelWithDictionary (NSDictionary dictionaryValue, out NSError error);

		// -(instancetype)initWithDictionary:(NSDictionary *)dictionaryValue error:(NSError **)error;
		[Export ("initWithDictionary:error:")]
		IntPtr Constructor (NSDictionary dictionaryValue, out NSError error);

		// +(NSSet *)propertyKeys;
		[Static]
		[Export ("propertyKeys")]
		[Verify (MethodToProperty)]
		NSSet PropertyKeys { get; }

		// @property (readonly, copy, nonatomic) NSDictionary * dictionaryValue;
		[Export ("dictionaryValue", ArgumentSemantic.Copy)]
		NSDictionary DictionaryValue { get; }

		// -(void)mergeValueForKey:(NSString *)key fromModel:(MTLModel *)model;
		[Export ("mergeValueForKey:fromModel:")]
		void MergeValueForKey (string key, MTLModel model);

		// -(void)mergeValuesForKeysFromModel:(MTLModel *)model;
		[Export ("mergeValuesForKeysFromModel:")]
		void MergeValuesForKeysFromModel (MTLModel model);

		// -(BOOL)isEqual:(id)object;
		[Export ("isEqual:")]
		bool IsEqual (NSObject @object);

		// -(NSString *)description;
		[Export ("description")]
		[Verify (MethodToProperty)]
		string Description { get; }
	}

	// @interface Validation (MTLModel)
	[Category]
	[BaseType (typeof(MTLModel))]
	interface MTLModel_Validation
	{
		// -(BOOL)validate:(NSError **)error;
		[Export ("validate:")]
		bool Validate (out NSError error);
	}

	// @interface Unavailable (MTLModel)
	[Category]
	[BaseType (typeof(MTLModel))]
	interface MTLModel_Unavailable
	{
		// +(instancetype)modelWithDictionary:(NSDictionary *)dictionaryValue __attribute__((deprecated("Replaced by +modelWithDictionary:error:")));
		[Static]
		[Export ("modelWithDictionary:")]
		MTLModel ModelWithDictionary (NSDictionary dictionaryValue);

		// -(instancetype)initWithDictionary:(NSDictionary *)dictionaryValue __attribute__((deprecated("Replaced by -initWithDictionary:error:")));
		[Export ("initWithDictionary:")]
		IntPtr Constructor (NSDictionary dictionaryValue);

		// +(instancetype)modelWithExternalRepresentation:(NSDictionary *)externalRepresentation __attribute__((deprecated("Replaced by -[MTLJSONAdapter initWithJSONDictionary:modelClass:]")));
//		[Static]
//		[Export ("modelWithExternalRepresentation:")]
//		MTLModel ModelWithExternalRepresentation (NSDictionary externalRepresentation);

		// -(instancetype)initWithExternalRepresentation:(NSDictionary *)externalRepresentation __attribute__((deprecated("Replaced by -[MTLJSONAdapter initWithJSONDictionary:modelClass:]")));
//		[Export ("initWithExternalRepresentation:")]
//		IntPtr Constructor (NSDictionary externalRepresentation);

		// @property (readonly, copy, nonatomic) NSDictionary * externalRepresentation;
		[Export ("externalRepresentation", ArgumentSemantic.Copy)]
		NSDictionary ExternalRepresentation { get; }

		// +(NSDictionary *)externalRepresentationKeyPathsByPropertyKey __attribute__((deprecated("Replaced by +JSONKeyPathsByPropertyKey in <MTLJSONSerializing>")));
		[Static]
		[Export ("externalRepresentationKeyPathsByPropertyKey")]
		[Verify (MethodToProperty)]
		NSDictionary ExternalRepresentationKeyPathsByPropertyKey { get; }

		// +(NSValueTransformer *)transformerForKey:(NSString *)key __attribute__((deprecated("Replaced by +JSONTransformerForKey: in <MTLJSONSerializing>")));
		[Static]
		[Export ("transformerForKey:")]
		NSValueTransformer TransformerForKey (string key);

		// +(NSDictionary *)migrateExternalRepresentation:(NSDictionary *)externalRepresentation fromVersion:(NSUInteger)fromVersion __attribute__((deprecated("Replaced by -decodeValueForKey:withCoder:modelVersion:")));
		[Static]
		[Export ("migrateExternalRepresentation:fromVersion:")]
		NSDictionary MigrateExternalRepresentation (NSDictionary externalRepresentation, nuint fromVersion);
	}

	[Verify (ConstantsInterfaceAssociation)]
	partial interface Constants
	{
		// extern NSString *const TriceLocalNotificationTriggerUidKey;
		[Field ("TriceLocalNotificationTriggerUidKey")]
		NSString TriceLocalNotificationTriggerUidKey { get; }
	}

	// @interface TriceAction : NSObject <NSCopying>
	[BaseType (typeof(NSObject))]
	interface TriceAction : INSCopying
	{
		// @property (nonatomic, weak) TriceTrigger * trigger;
		[Export ("trigger", ArgumentSemantic.Weak)]
		TriceTrigger Trigger { get; set; }

		// +(instancetype)action:(void (^)())action;
		[Static]
		[Export ("action:")]
		TriceAction Action (Action action);

		// +(instancetype)pushNotificationAction:(void (^)(UILocalNotification *))notificationConfigurationBlock;
		[Static]
		[Export ("pushNotificationAction:")]
		TriceAction PushNotificationAction (Action<UILocalNotification> notificationConfigurationBlock);

		// +(instancetype)urlCallbackAction:(TriceURLCallbackType)type url:(NSString *)url parameters:(NSDictionary *)parameters;
		[Static]
		[Export ("urlCallbackAction:url:parameters:")]
		TriceAction UrlCallbackAction (TriceURLCallbackType type, string url, NSDictionary parameters);

		// -(void)fire;
		[Export ("fire")]
		void Fire ();
	}

	// @protocol MTLJSONSerializing
	[Protocol, Model]
	interface MTLJSONSerializing
	{
		// @required +(NSDictionary *)JSONKeyPathsByPropertyKey;
		[Static, Abstract]
		[Export ("JSONKeyPathsByPropertyKey")]
		[Verify (MethodToProperty)]
		NSDictionary JSONKeyPathsByPropertyKey { get; }

		// @optional +(NSValueTransformer *)JSONTransformerForKey:(NSString *)key;
		[Static]
		[Export ("JSONTransformerForKey:")]
		NSValueTransformer JSONTransformerForKey (string key);

		// @optional +(Class)classForParsingJSONDictionary:(NSDictionary *)JSONDictionary;
		[Static]
		[Export ("classForParsingJSONDictionary:")]
		Class ClassForParsingJSONDictionary (NSDictionary JSONDictionary);
	}

	[Verify (ConstantsInterfaceAssociation)]
	partial interface Constants
	{
		// extern NSString *const MTLJSONAdapterErrorDomain;
		[Field ("MTLJSONAdapterErrorDomain")]
		NSString MTLJSONAdapterErrorDomain { get; }

		// extern const NSInteger MTLJSONAdapterErrorNoClassFound;
		[Field ("MTLJSONAdapterErrorNoClassFound")]
		nint MTLJSONAdapterErrorNoClassFound { get; }

		// extern const NSInteger MTLJSONAdapterErrorInvalidJSONDictionary;
		[Field ("MTLJSONAdapterErrorInvalidJSONDictionary")]
		nint MTLJSONAdapterErrorInvalidJSONDictionary { get; }

		// extern const NSInteger MTLJSONAdapterErrorInvalidJSONMapping;
		[Field ("MTLJSONAdapterErrorInvalidJSONMapping")]
		nint MTLJSONAdapterErrorInvalidJSONMapping { get; }
	}

	// @interface MTLJSONAdapter : NSObject
	[BaseType (typeof(NSObject))]
	interface MTLJSONAdapter
	{
		// @property (readonly, nonatomic, strong) MTLModel<MTLJSONSerializing> * model;
		[Export ("model", ArgumentSemantic.Strong)]
		MTLJSONSerializing Model { get; }

		// +(id)modelOfClass:(Class)modelClass fromJSONDictionary:(NSDictionary *)JSONDictionary error:(NSError **)error;
		[Static]
		[Export ("modelOfClass:fromJSONDictionary:error:")]
		NSObject ModelOfClass (Class modelClass, NSDictionary JSONDictionary, out NSError error);

		// +(NSArray *)modelsOfClass:(Class)modelClass fromJSONArray:(NSArray *)JSONArray error:(NSError **)error;
		[Static]
		[Export ("modelsOfClass:fromJSONArray:error:")]
		[Verify (StronglyTypedNSArray), Verify (StronglyTypedNSArray)]
		NSObject[] ModelsOfClass (Class modelClass, NSObject[] JSONArray, out NSError error);

		// +(NSDictionary *)JSONDictionaryFromModel:(MTLModel<MTLJSONSerializing> *)model;
		[Static]
		[Export ("JSONDictionaryFromModel:")]
		NSDictionary JSONDictionaryFromModel (MTLJSONSerializing model);

		// +(NSArray *)JSONArrayFromModels:(NSArray *)models;
		[Static]
		[Export ("JSONArrayFromModels:")]
		[Verify (StronglyTypedNSArray), Verify (StronglyTypedNSArray)]
		NSObject[] JSONArrayFromModels (NSObject[] models);

		// -(id)initWithJSONDictionary:(NSDictionary *)JSONDictionary modelClass:(Class)modelClass error:(NSError **)error;
		[Export ("initWithJSONDictionary:modelClass:error:")]
		IntPtr Constructor (NSDictionary JSONDictionary, Class modelClass, out NSError error);

		// -(id)initWithModel:(MTLModel<MTLJSONSerializing> *)model;
		[Export ("initWithModel:")]
		IntPtr Constructor (MTLJSONSerializing model);

		// -(NSDictionary *)JSONDictionary;
		[Export ("JSONDictionary")]
		[Verify (MethodToProperty)]
		NSDictionary JSONDictionary { get; }

		// -(NSString *)JSONKeyPathForPropertyKey:(NSString *)key;
		[Export ("JSONKeyPathForPropertyKey:")]
		string JSONKeyPathForPropertyKey (string key);
	}

	[Verify (ConstantsInterfaceAssociation)]
	partial interface Constants
	{
		// extern NSString *const TriceTriggerWillFireNotification;
		[Field ("TriceTriggerWillFireNotification")]
		NSString TriceTriggerWillFireNotification { get; }

		// extern NSString *const TriceTriggerDidFireNotification;
		[Field ("TriceTriggerDidFireNotification")]
		NSString TriceTriggerDidFireNotification { get; }
	}

	// @interface TriceTrigger : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceTrigger : MTLJSONSerializing
	{
		// @property (readonly, copy, nonatomic) NSString * uid;
		[Export ("uid")]
		string Uid { get; }

		// @property (copy, nonatomic) NSString * name;
		[Export ("name")]
		string Name { get; set; }

		// @property (readonly, assign, nonatomic) NSTimeInterval frequency;
		[Export ("frequency")]
		double Frequency { get; }

		// @property (readonly, assign, nonatomic) NSUInteger limit;
		[Export ("limit", ArgumentSemantic.Assign)]
		nuint Limit { get; }

		// @property (readonly, assign, nonatomic) NSUInteger fireCount;
		[Export ("fireCount", ArgumentSemantic.Assign)]
		nuint FireCount { get; }

		// @property (readonly, assign, nonatomic) TriceTriggerEvent event;
		[Export ("event", ArgumentSemantic.Assign)]
		TriceTriggerEvent Event { get; }

		// @property (readonly, assign, nonatomic) NSTimeInterval dwellTime;
		[Export ("dwellTime")]
		double DwellTime { get; }

		// @property (readonly, copy, nonatomic) NSArray * actions;
		[Export ("actions", ArgumentSemantic.Copy)]
		[Verify (StronglyTypedNSArray)]
		NSObject[] Actions { get; }

		// @property (readonly, copy, nonatomic) NSDictionary * linkedPointOfInterest;
		[Export ("linkedPointOfInterest", ArgumentSemantic.Copy)]
		NSDictionary LinkedPointOfInterest { get; }

		// @property (nonatomic, weak) TriceZone * zone;
		[Export ("zone", ArgumentSemantic.Weak)]
		TriceZone Zone { get; set; }

		// +(instancetype)triggerWithEvent:(TriceTriggerEvent)event frequency:(NSInteger)frequency limit:(NSUInteger)limit;
		[Static]
		[Export ("triggerWithEvent:frequency:limit:")]
		TriceTrigger TriggerWithEvent (TriceTriggerEvent @event, nint frequency, nuint limit);

		// +(instancetype)triggerWithDwellTime:(NSTimeInterval)dwellTime frequency:(NSInteger)frequency limit:(NSUInteger)limit;
		[Static]
		[Export ("triggerWithDwellTime:frequency:limit:")]
		TriceTrigger TriggerWithDwellTime (double dwellTime, nint frequency, nuint limit);

		// -(void)setInternalStateToSameAs:(TriceTrigger *)trigger;
		[Export ("setInternalStateToSameAs:")]
		void SetInternalStateToSameAs (TriceTrigger trigger);

		// -(void)addAction:(TriceAction *)action;
		[Export ("addAction:")]
		void AddAction (TriceAction action);

		// -(BOOL)shouldFire;
		[Export ("shouldFire")]
		[Verify (MethodToProperty)]
		bool ShouldFire { get; }

		// -(void)fire;
		[Export ("fire")]
		void Fire ();

		// -(void)cancelFiring;
		[Export ("cancelFiring")]
		void CancelFiring ();
	}

	// @interface TriceBeacon : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceBeacon : MTLJSONSerializing
	{
		// @property (readonly, nonatomic, strong) NSUUID * proximityUUID;
		[Export ("proximityUUID", ArgumentSemantic.Strong)]
		NSUUID ProximityUUID { get; }

		// @property (readonly, nonatomic, strong) NSNumber * major;
		[Export ("major", ArgumentSemantic.Strong)]
		NSNumber Major { get; }

		// @property (readonly, nonatomic, strong) NSNumber * minor;
		[Export ("minor", ArgumentSemantic.Strong)]
		NSNumber Minor { get; }

		// @property (readonly, assign, nonatomic) CLProximity proximity;
		[Export ("proximity", ArgumentSemantic.Assign)]
		CLProximity Proximity { get; }

		// @property (readonly, assign, nonatomic) CLProximity rssiProximity;
		[Export ("rssiProximity", ArgumentSemantic.Assign)]
		CLProximity RssiProximity { get; }

		// @property (readonly, assign, nonatomic) CLProximity distanceProximity;
		[Export ("distanceProximity", ArgumentSemantic.Assign)]
		CLProximity DistanceProximity { get; }

		// @property (readonly, assign, nonatomic) CLLocationAccuracy accuracy;
		[Export ("accuracy")]
		double Accuracy { get; }

		// @property (readonly, assign, nonatomic) NSInteger rssi;
		[Export ("rssi", ArgumentSemantic.Assign)]
		nint Rssi { get; }

		// @property (readonly, copy, nonatomic) NSString * identifier;
		[Export ("identifier")]
		string Identifier { get; }

		// @property (readonly, copy, nonatomic) NSString * serverId;
		[Export ("serverId")]
		string ServerId { get; }

		// @property (readonly, copy, nonatomic) NSString * macAddress;
		[Export ("macAddress")]
		string MacAddress { get; }

		// @property (readonly, assign, nonatomic) NSInteger power;
		[Export ("power", ArgumentSemantic.Assign)]
		nint Power { get; }

		// @property (readonly, assign, nonatomic) TriceBeaconManufacturer manufacturer;
		[Export ("manufacturer", ArgumentSemantic.Assign)]
		TriceBeaconManufacturer Manufacturer { get; }

		// @property (readonly, getter = isPendingUpdate, assign, nonatomic) BOOL pendingUpdate;
		[Export ("pendingUpdate")]
		bool PendingUpdate { [Bind ("isPendingUpdate")] get; }

		// @property (readonly, assign, nonatomic) BOOL shouldConnectOnPing;
		[Export ("shouldConnectOnPing")]
		bool ShouldConnectOnPing { get; }

		// @property (assign, nonatomic) CBPeripheralState connectionState;
		[Export ("connectionState", ArgumentSemantic.Assign)]
		CBPeripheralState ConnectionState { get; set; }

		// @property (getter = isMoving, assign, nonatomic) BOOL moving;
		[Export ("moving")]
		bool Moving { [Bind ("isMoving")] get; set; }

		// @property (readonly, assign, nonatomic) NSInteger batteryPercentage;
		[Export ("batteryPercentage", ArgumentSemantic.Assign)]
		nint BatteryPercentage { get; }

		// @property (readonly, assign, nonatomic) NSInteger interval;
		[Export ("interval", ArgumentSemantic.Assign)]
		nint Interval { get; }

		// @property (readonly, copy, nonatomic) NSString * hardwareVersion;
		[Export ("hardwareVersion")]
		string HardwareVersion { get; }

		// @property (readonly, copy, nonatomic) NSString * firmwareVersion;
		[Export ("firmwareVersion")]
		string FirmwareVersion { get; }

		// +(instancetype)beaconWithMajor:(CLBeaconMajorValue)major minor:(CLBeaconMinorValue)minor proximityUuid:(NSUUID *)proximityUuid;
		[Static]
		[Export ("beaconWithMajor:minor:proximityUuid:")]
		TriceBeacon BeaconWithMajor (ushort major, ushort minor, NSUuid proximityUuid);

		// +(instancetype)beaconWithBeacon:(CLBeacon *)beacon;
		[Static]
		[Export ("beaconWithBeacon:")]
		TriceBeacon BeaconWithBeacon (CLBeacon beacon);

		// -(void)updateBeacon:(CLBeacon *)beacon;
		[Export ("updateBeacon:")]
		void UpdateBeacon (CLBeacon beacon);

		// -(BOOL)isEqualToBeacon:(CLBeacon *)beacon;
		[Export ("isEqualToBeacon:")]
		bool IsEqualToBeacon (CLBeacon beacon);

		// -(BOOL)isEqualToPeripheral:(CBPeripheral *)peripheral;
		[Export ("isEqualToPeripheral:")]
		bool IsEqualToPeripheral (CBPeripheral peripheral);
	}

	// @interface TriceIdentifier (CLBeacon)
	[Category]
	[BaseType (typeof(CLBeacon))]
	interface CLBeacon_TriceIdentifier
	{
		// -(NSString *)identifier;
		[Export ("identifier")]
		[Verify (MethodToProperty)]
		string Identifier { get; }
	}

	[Verify (ConstantsInterfaceAssociation)]
	partial interface Constants
	{
		// extern NSString *const TriceZoneStateDidChangeNotification;
		[Field ("TriceZoneStateDidChangeNotification")]
		NSString TriceZoneStateDidChangeNotification { get; }
	}

	// @interface TriceZone : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceZone : MTLJSONSerializing
	{
		// @property (readonly, copy, nonatomic) NSString * uid;
		[Export ("uid")]
		string Uid { get; }

		// @property (copy, nonatomic) NSString * name;
		[Export ("name")]
		string Name { get; set; }

		// @property (readonly, assign, nonatomic) TriceZoneType type;
		[Export ("type", ArgumentSemantic.Assign)]
		TriceZoneType Type { get; }

		// @property (readonly, copy, nonatomic) NSSet * triggers;
		[Export ("triggers", ArgumentSemantic.Copy)]
		NSSet Triggers { get; }

		// @property (readonly, assign, nonatomic) TriceZoneState state;
		[Export ("state", ArgumentSemantic.Assign)]
		TriceZoneState State { get; }

		// @property (readonly, assign, nonatomic) NSTimeInterval currentDwellTime;
		[Export ("currentDwellTime")]
		double CurrentDwellTime { get; }

		// @property (readonly, assign, nonatomic) CLLocationDistance currentDistanceAway;
		[Export ("currentDistanceAway")]
		double CurrentDistanceAway { get; }

		// -(void)addTrigger:(TriceTrigger *)trigger;
		[Export ("addTrigger:")]
		void AddTrigger (TriceTrigger trigger);

		// -(NSSet *)triggersMatchingDescriptor:(TriceObjectDescriptor *)descriptor;
		[Export ("triggersMatchingDescriptor:")]
		NSSet TriggersMatchingDescriptor (TriceObjectDescriptor descriptor);

		// -(void)setInternalStateSameAs:(TriceZone *)zone;
		[Export ("setInternalStateSameAs:")]
		void SetInternalStateSameAs (TriceZone zone);

		// -(void)update;
		[Export ("update")]
		void Update ();
	}

	// @interface TriceGeoZone : TriceZone
	[BaseType (typeof(TriceZone))]
	interface TriceGeoZone
	{
		// @property (nonatomic, strong) CLLocation * userLocation;
		[Export ("userLocation", ArgumentSemantic.Strong)]
		CLLocation UserLocation { get; set; }
	}

	// @interface TriceGeoRadiusZone : TriceGeoZone
	[BaseType (typeof(TriceGeoZone))]
	interface TriceGeoRadiusZone
	{
		// @property (readonly, assign, nonatomic) CLLocationCoordinate2D coordinate;
		[Export ("coordinate", ArgumentSemantic.Assign)]
		CLLocationCoordinate2D Coordinate { get; }

		// @property (readonly, assign, nonatomic) CLLocationDistance radius;
		[Export ("radius")]
		double Radius { get; }

		// +(instancetype)geoRadiusZoneWithCoordinate:(CLLocationCoordinate2D)coordinate radius:(CLLocationDistance)radius;
		[Static]
		[Export ("geoRadiusZoneWithCoordinate:radius:")]
		TriceGeoRadiusZone GeoRadiusZoneWithCoordinate (CLLocationCoordinate2D coordinate, double radius);
	}

	// @interface TriceGeoPolygonZone : TriceGeoZone
	[BaseType (typeof(TriceGeoZone))]
	interface TriceGeoPolygonZone
	{
		// @property (readonly, copy, nonatomic) NSArray * polygonCoordinates;
		[Export ("polygonCoordinates", ArgumentSemantic.Copy)]
		[Verify (StronglyTypedNSArray)]
		NSObject[] PolygonCoordinates { get; }

		// +(instancetype)geoPolygonZoneWithCoordinates:(NSArray *)coordinates;
		[Static]
		[Export ("geoPolygonZoneWithCoordinates:")]
		[Verify (StronglyTypedNSArray)]
		TriceGeoPolygonZone GeoPolygonZoneWithCoordinates (NSObject[] coordinates);
	}

	// @interface TriceBeaconZone : TriceZone
	[BaseType (typeof(TriceZone))]
	interface TriceBeaconZone
	{
		// @property (readonly, assign, nonatomic) CLProximity proximity;
		[Export ("proximity", ArgumentSemantic.Assign)]
		CLProximity Proximity { get; }

		// @property (readonly, nonatomic, strong) TriceBeacon * beacon;
		[Export ("beacon", ArgumentSemantic.Strong)]
		TriceBeacon Beacon { get; }

		// @property (readonly, assign, nonatomic) BOOL backgroundPing;
		[Export ("backgroundPing")]
		bool BackgroundPing { get; }

		// +(instancetype)beaconZoneWithBeacon:(TriceBeacon *)beacon proximity:(CLProximity)proximity;
		[Static]
		[Export ("beaconZoneWithBeacon:proximity:")]
		TriceBeaconZone BeaconZoneWithBeacon (TriceBeacon beacon, CLProximity proximity);
	}

	// @interface TriceIndoorZone : TriceZone
	[BaseType (typeof(TriceZone))]
	interface TriceIndoorZone
	{
	}

	// @interface TriceTriggerManager : NSObject
	[BaseType (typeof(NSObject))]
	interface TriceTriggerManager
	{
		// @property (readonly, copy, nonatomic) NSSet * zones;
		[Export ("zones", ArgumentSemantic.Copy)]
		NSSet Zones { get; }

		// @property (readonly, copy, nonatomic) NSSet * zonesInside;
		[Export ("zonesInside", ArgumentSemantic.Copy)]
		NSSet ZonesInside { get; }

		// @property (copy, nonatomic) void (^handleErrorBlock)(NSError *);
		[Export ("handleErrorBlock", ArgumentSemantic.Copy)]
		Action<NSError> HandleErrorBlock { get; set; }

		// @property (assign, nonatomic) BOOL allowEncodingZonesToDisk;
		[Export ("allowEncodingZonesToDisk")]
		bool AllowEncodingZonesToDisk { get; set; }

		// -(void)startMonitoringZones;
		[Export ("startMonitoringZones")]
		void StartMonitoringZones ();

		// -(void)startMonitoringBeaconZones;
		[Export ("startMonitoringBeaconZones")]
		void StartMonitoringBeaconZones ();

		// -(void)startMonitoringGPSZones;
		[Export ("startMonitoringGPSZones")]
		void StartMonitoringGPSZones ();

		// -(void)stopMonitoringZones;
		[Export ("stopMonitoringZones")]
		void StopMonitoringZones ();

		// -(void)addZone:(TriceZone *)zone;
		[Export ("addZone:")]
		void AddZone (TriceZone zone);

		// -(void)addAction:(TriceAction *)action toTrigger:(TriceObjectDescriptor *)triggerDescriptor zone:(TriceObjectDescriptor *)zoneDescriptor;
		[Export ("addAction:toTrigger:zone:")]
		void AddAction (TriceAction action, TriceObjectDescriptor triggerDescriptor, TriceObjectDescriptor zoneDescriptor);

		// -(NSSet *)zonesMatchingDescriptor:(TriceObjectDescriptor *)descriptor;
		[Export ("zonesMatchingDescriptor:")]
		NSSet ZonesMatchingDescriptor (TriceObjectDescriptor descriptor);
	}

	// @interface TriceAppDelegateProxy : NSProxy <UIApplicationDelegate>
	[BaseType (typeof(NSProxy))]
	interface TriceAppDelegateProxy : IUIApplicationDelegate
	{
		// +(void)handleTriceKitLocalNotifications;
		[Static]
		[Export ("handleTriceKitLocalNotifications")]
		void HandleTriceKitLocalNotifications ();
	}

	// @interface TriceBuilding : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceBuilding : MTLJSONSerializing
	{
		// @property (readonly, copy, nonatomic) NSString * uid;
		[Export ("uid")]
		string Uid { get; }

		// @property (readonly, copy, nonatomic) NSString * name;
		[Export ("name")]
		string Name { get; }

		// @property (readonly, copy, nonatomic) NSString * buildingDescription;
		[Export ("buildingDescription")]
		string BuildingDescription { get; }

		// @property (readonly, copy, nonatomic) NSString * imageUrl;
		[Export ("imageUrl")]
		string ImageUrl { get; }

		// @property (readonly, nonatomic, strong) TriceAddress * address;
		[Export ("address", ArgumentSemantic.Strong)]
		TriceAddress Address { get; }

		// @property (readonly, assign, nonatomic) CLLocationCoordinate2D coordinate;
		[Export ("coordinate", ArgumentSemantic.Assign)]
		CLLocationCoordinate2D Coordinate { get; }

		// @property (copy, nonatomic) NSArray * floors;
		[Export ("floors", ArgumentSemantic.Copy)]
		[Verify (StronglyTypedNSArray)]
		NSObject[] Floors { get; set; }

		// -(NSArray *)allMarkers;
		[Export ("allMarkers")]
		[Verify (MethodToProperty), Verify (StronglyTypedNSArray)]
		NSObject[] AllMarkers { get; }
	}

	// @interface TriceAddress : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceAddress : MTLJSONSerializing
	{
		// @property (readonly, copy, nonatomic) NSString * street;
		[Export ("street")]
		string Street { get; }

		// @property (readonly, copy, nonatomic) NSString * city;
		[Export ("city")]
		string City { get; }

		// @property (readonly, copy, nonatomic) NSString * state;
		[Export ("state")]
		string State { get; }

		// @property (readonly, copy, nonatomic) NSString * country;
		[Export ("country")]
		string Country { get; }

		// @property (readonly, copy, nonatomic) NSString * postalCode;
		[Export ("postalCode")]
		string PostalCode { get; }
	}

	// @interface TriceFloor : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceFloor : MTLJSONSerializing
	{
		// @property (readonly, copy, nonatomic) NSString * uid;
		[Export ("uid")]
		string Uid { get; }

		// @property (readonly, copy, nonatomic) NSString * name;
		[Export ("name")]
		string Name { get; }

		// @property (readonly, assign, nonatomic) NSInteger level;
		[Export ("level", ArgumentSemantic.Assign)]
		nint Level { get; }

		// @property (readonly, copy, nonatomic) NSString * imageUrl;
		[Export ("imageUrl")]
		string ImageUrl { get; }

		// @property (readonly, assign, nonatomic) CLLocationDegrees offset;
		[Export ("offset")]
		double Offset { get; }

		// @property (readonly, assign, nonatomic) CGSize imageSize;
		[Export ("imageSize", ArgumentSemantic.Assign)]
		CGSize ImageSize { get; }

		// @property (readonly, copy, nonatomic) NSArray * rooms;
		[Export ("rooms", ArgumentSemantic.Copy)]
		[Verify (StronglyTypedNSArray)]
		NSObject[] Rooms { get; }

		// @property (copy, nonatomic) NSArray * markers;
		[Export ("markers", ArgumentSemantic.Copy)]
		[Verify (StronglyTypedNSArray)]
		NSObject[] Markers { get; set; }

		// @property (copy, nonatomic) NSArray * beacons;
		[Export ("beacons", ArgumentSemantic.Copy)]
		[Verify (StronglyTypedNSArray)]
		NSObject[] Beacons { get; set; }

		// @property (copy, nonatomic) NSArray * trainingPoints;
		[Export ("trainingPoints", ArgumentSemantic.Copy)]
		[Verify (StronglyTypedNSArray)]
		NSObject[] TrainingPoints { get; set; }

		// @property (nonatomic, weak) TriceBuilding * building;
		[Export ("building", ArgumentSemantic.Weak)]
		TriceBuilding Building { get; set; }
	}

	// @interface TriceRoom : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceRoom : MTLJSONSerializing
	{
		// @property (readonly, copy, nonatomic) NSString * uid;
		[Export ("uid")]
		string Uid { get; }

		// @property (readonly, copy, nonatomic) NSString * name;
		[Export ("name")]
		string Name { get; }

		// @property (nonatomic, weak) TriceFloor * floor;
		[Export ("floor", ArgumentSemantic.Weak)]
		TriceFloor Floor { get; set; }
	}

	// @interface TriceMarker : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceMarker : MTLJSONSerializing
	{
		// @property (readonly, copy, nonatomic) NSString * uid;
		[Export ("uid")]
		string Uid { get; }

		// @property (readonly, copy, nonatomic) NSString * roomUid;
		[Export ("roomUid")]
		string RoomUid { get; }

		// @property (readonly, assign, nonatomic) TriceMarkerType type;
		[Export ("type", ArgumentSemantic.Assign)]
		TriceMarkerType Type { get; }

		// @property (readonly, copy, nonatomic) NSString * subtype;
		[Export ("subtype")]
		string Subtype { get; }

		// @property (readonly, copy, nonatomic) NSString * name;
		[Export ("name")]
		string Name { get; }

		// @property (readonly, assign, nonatomic) CGPoint coordinate;
		[Export ("coordinate", ArgumentSemantic.Assign)]
		CGPoint Coordinate { get; }

		// @property (readonly, copy, nonatomic) NSString * iconUrl;
		[Export ("iconUrl")]
		string IconUrl { get; }

		// @property (readonly, copy, nonatomic) NSString * storyImageUrl;
		[Export ("storyImageUrl")]
		string StoryImageUrl { get; }

		// @property (readonly, copy, nonatomic) NSString * storyUid;
		[Export ("storyUid")]
		string StoryUid { get; }

		// @property (nonatomic, weak) TriceFloor * floor;
		[Export ("floor", ArgumentSemantic.Weak)]
		TriceFloor Floor { get; set; }
	}

	// @interface TriceDirections : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceDirections : MTLJSONSerializing
	{
		// @property (readonly, assign, nonatomic) CGFloat distance;
		[Export ("distance", ArgumentSemantic.Assign)]
		nfloat Distance { get; }

		// @property (readonly, assign, nonatomic) CLLocationDistance distanceMetres;
		[Export ("distanceMetres")]
		double DistanceMetres { get; }

		// @property (readonly, assign, nonatomic) NSInteger durationSeconds;
		[Export ("durationSeconds", ArgumentSemantic.Assign)]
		nint DurationSeconds { get; }

		// @property (readonly, copy, nonatomic) NSString * duration;
		[Export ("duration")]
		string Duration { get; }

		// @property (readonly, copy, nonatomic) NSArray * steps;
		[Export ("steps", ArgumentSemantic.Copy)]
		[Verify (StronglyTypedNSArray)]
		NSObject[] Steps { get; }

		// @property (nonatomic, strong) TriceMarker * fromLocation;
		[Export ("fromLocation", ArgumentSemantic.Strong)]
		TriceMarker FromLocation { get; set; }

		// @property (nonatomic, strong) TriceMarker * toLocation;
		[Export ("toLocation", ArgumentSemantic.Strong)]
		TriceMarker ToLocation { get; set; }

		// @property (getter = isAccessibleRoute, assign, nonatomic) BOOL accessibleRoute;
		[Export ("accessibleRoute")]
		bool AccessibleRoute { [Bind ("isAccessibleRoute")] get; set; }

		// @property (assign, nonatomic) NSInteger currentStepIndex;
		[Export ("currentStepIndex", ArgumentSemantic.Assign)]
		nint CurrentStepIndex { get; set; }
	}

	// @interface TriceDirectionStep : MTLModel <MTLJSONSerializing>
	[BaseType (typeof(MTLModel))]
	interface TriceDirectionStep : MTLJSONSerializing
	{
		// @property (readonly, copy, nonatomic) NSString * uid;
		[Export ("uid")]
		string Uid { get; }

		// @property (readonly, assign, nonatomic) CGPoint location;
		[Export ("location", ArgumentSemantic.Assign)]
		CGPoint Location { get; }

		// @property (readonly, assign, nonatomic) CGFloat distanceToNextPoint;
		[Export ("distanceToNextPoint", ArgumentSemantic.Assign)]
		nfloat DistanceToNextPoint { get; }

		// @property (readonly, assign, nonatomic) CLLocationDistance distanceToNextPointMetres;
		[Export ("distanceToNextPointMetres")]
		double DistanceToNextPointMetres { get; }

		// @property (readonly, assign, nonatomic) CGFloat headingToNextPoint;
		[Export ("headingToNextPoint", ArgumentSemantic.Assign)]
		nfloat HeadingToNextPoint { get; }

		// @property (readonly, assign, nonatomic) NSInteger durationToNextPointSeconds;
		[Export ("durationToNextPointSeconds", ArgumentSemantic.Assign)]
		nint DurationToNextPointSeconds { get; }

		// @property (readonly, copy, nonatomic) NSString * directionsToNextPoint;
		[Export ("directionsToNextPoint")]
		string DirectionsToNextPoint { get; }

		// @property (readonly, copy, nonatomic) NSString * durationToNextPoint;
		[Export ("durationToNextPoint")]
		string DurationToNextPoint { get; }

		// @property (readonly, copy, nonatomic) NSString * iconUrl;
		[Export ("iconUrl")]
		string IconUrl { get; }
	}

	[Verify (ConstantsInterfaceAssociation)]
	partial interface Constants
	{
		// extern NSString *const TriceMapViewFloorplanImageDidLoadNotification;
		[Field ("TriceMapViewFloorplanImageDidLoadNotification")]
		NSString TriceMapViewFloorplanImageDidLoadNotification { get; }
	}

	// @interface TriceMapView : GLKView
	[BaseType (typeof(GLKView))]
	interface TriceMapView
	{
		// @property (nonatomic, strong) TriceDirections * routeDirections;
		[Export ("routeDirections", ArgumentSemantic.Strong)]
		TriceDirections RouteDirections { get; set; }

		// @property (nonatomic, strong) TriceBuilding * building;
		[Export ("building", ArgumentSemantic.Strong)]
		TriceBuilding Building { get; set; }

		// @property (nonatomic, strong) TriceFloor * currentFloor;
		[Export ("currentFloor", ArgumentSemantic.Strong)]
		TriceFloor CurrentFloor { get; set; }

		// @property (assign, nonatomic) NSInteger currentFloorIndex;
		[Export ("currentFloorIndex", ArgumentSemantic.Assign)]
		nint CurrentFloorIndex { get; set; }

		[Wrap ("WeakMapDelegate")]
		TriceMapViewDelegate MapDelegate { get; set; }

		// @property (nonatomic, weak) id<TriceMapViewDelegate> mapDelegate;
		[NullAllowed, Export ("mapDelegate", ArgumentSemantic.Weak)]
		NSObject WeakMapDelegate { get; set; }

		// @property (assign, nonatomic) CGRect cameraFrame;
		[Export ("cameraFrame", ArgumentSemantic.Assign)]
		CGRect CameraFrame { get; set; }

		// @property (getter = isLockedOnUserLocation, assign, nonatomic) BOOL lockedOnUserLocation;
		[Export ("lockedOnUserLocation")]
		bool LockedOnUserLocation { [Bind ("isLockedOnUserLocation")] get; set; }

		// -(void)setCameraFrameToRouteOverview;
		[Export ("setCameraFrameToRouteOverview")]
		void SetCameraFrameToRouteOverview ();

		// -(void)setCameraFrameToRouteStepIndex:(NSInteger)index;
		[Export ("setCameraFrameToRouteStepIndex:")]
		void SetCameraFrameToRouteStepIndex (nint index);

		// -(void)cancelAllMapRequests;
		[Export ("cancelAllMapRequests")]
		void CancelAllMapRequests ();
	}

	// @protocol TriceMapViewDelegate <NSObject>
	[Protocol, Model]
	[BaseType (typeof(NSObject))]
	interface TriceMapViewDelegate
	{
		// @optional -(void)triceMapViewDidStartUpdatingUserLocation:(TriceMapView *)mapView;
		[Export ("triceMapViewDidStartUpdatingUserLocation:")]
		void TriceMapViewDidStartUpdatingUserLocation (TriceMapView mapView);

		// @optional -(void)triceMapViewWasTapped:(TriceMapView *)mapView;
		[Export ("triceMapViewWasTapped:")]
		void TriceMapViewWasTapped (TriceMapView mapView);

		// @optional -(void)triceMapView:(TriceMapView *)mapView didSelectMarker:(TriceMarker *)marker;
		[Export ("triceMapView:didSelectMarker:")]
		void DidSelectMarker (TriceMapView mapView, TriceMarker marker);

		// @optional -(void)triceMapView:(TriceMapView *)mapView regionWillChangeAnimated:(BOOL)animated;
		[Export ("triceMapView:regionWillChangeAnimated:")]
		void WillChangeAnimated (TriceMapView mapView, bool animated);

		// @optional -(void)triceMapView:(TriceMapView *)mapView regionDidChangeAnimated:(BOOL)animated;
		[Export ("triceMapView:regionDidChangeAnimated:")]
		void DidChangeAnimated (TriceMapView mapView, bool animated);
	}

	// @protocol TriceLoadingViewDelegate <NSObject>
	[Protocol, Model]
	[BaseType (typeof(NSObject))]
	interface TriceLoadingViewDelegate
	{
		// @required @property (nonatomic, strong) UIView * targetView;
		[Export ("targetView", ArgumentSemantic.Strong)]
		UIView TargetView { get; set; }

		// @required -(void)startLoadingAnimated:(BOOL)animated;
		[Abstract]
		[Export ("startLoadingAnimated:")]
		void StartLoadingAnimated (bool animated);

		// @required -(void)stopLoadingAnimated:(BOOL)animated;
		[Abstract]
		[Export ("stopLoadingAnimated:")]
		void StopLoadingAnimated (bool animated);
	}

	// @interface TriceMapViewController : GLKViewController <TriceMapViewDelegate>
	[BaseType (typeof(GLKViewController))]
	interface TriceMapViewController : TriceMapViewDelegate
	{
		// @property (nonatomic, strong) UIView<TriceLoadingViewDelegate> * loadingView;
		[Export ("loadingView", ArgumentSemantic.Strong)]
		TriceLoadingViewDelegate LoadingView { get; set; }

		// @property (readonly, nonatomic, strong) TriceMapView * mapView;
		[Export ("mapView", ArgumentSemantic.Strong)]
		TriceMapView MapView { get; }

		// @property (copy, nonatomic) void (^markerSelectedAction)(TriceMarker *);
		[Export ("markerSelectedAction", ArgumentSemantic.Copy)]
		Action<TriceMarker> MarkerSelectedAction { get; set; }

		// +(instancetype)mapViewControllerForBuilding:(BOOL (^)(TriceBuilding *))buildingSelectionBlock;
		[Static]
		[Export ("mapViewControllerForBuilding:")]
		TriceMapViewController MapViewControllerForBuilding (Func<TriceBuilding, bool> buildingSelectionBlock);
	}
}