nativescript-cast-ns6-beta/platforms/ios/typings/objc!GoogleCast.d.ts

NativeScript Chromecast Plugin.

declare const enum GCKActiveInputStatus {

	Unknown = -1,

	Inactive = 0,

	Active = 1
}

declare class GCKAdBreakClipInfo extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKAdBreakClipInfo; // inherited from NSObject

	static new(): GCKAdBreakClipInfo; // inherited from NSObject

	readonly adBreakClipID: string;

	readonly clickThroughURL: NSURL;

	readonly contentID: string;

	readonly contentURL: NSURL;

	readonly customData: any;

	readonly duration: number;

	readonly hlsSegmentFormat: GCKHLSSegmentFormat;

	readonly mimeType: string;

	readonly posterURL: NSURL;

	readonly title: string;

	readonly vastAdsRequest: GCKAdBreakClipVastAdsRequest;

	readonly whenSkippable: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;
}

declare class GCKAdBreakClipVastAdsRequest extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKAdBreakClipVastAdsRequest; // inherited from NSObject

	static new(): GCKAdBreakClipVastAdsRequest; // inherited from NSObject

	readonly adTagUrl: NSURL;

	readonly adsResponse: string;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;
}

declare class GCKAdBreakInfo extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKAdBreakInfo; // inherited from NSObject

	static new(): GCKAdBreakInfo; // inherited from NSObject

	readonly adBreakClipIDs: NSArray<string>;

	readonly adBreakID: string;

	readonly embedded: boolean;

	readonly playbackPosition: number;

	readonly watched: boolean;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { playbackPosition: number; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithPlaybackPosition(playbackPosition: number): this;
}

declare class GCKAdBreakStatus extends NSObject implements NSCopying {

	static alloc(): GCKAdBreakStatus; // inherited from NSObject

	static new(): GCKAdBreakStatus; // inherited from NSObject

	readonly adBreakClipID: string;

	readonly adBreakID: string;

	readonly currentAdBreakClipTime: number;

	readonly currentAdBreakTime: number;

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;
}

declare class GCKApplicationMetadata extends NSObject implements NSCopying {

	static alloc(): GCKApplicationMetadata; // inherited from NSObject

	static new(): GCKApplicationMetadata; // inherited from NSObject

	readonly applicationID: string;

	readonly applicationName: string;

	readonly images: NSArray<GCKImage>;

	readonly namespaces: NSArray<string>;

	readonly senderApplicationInfo: GCKSenderApplicationInfo;

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	senderAppIdentifier(): string;

	senderAppLaunchURL(): NSURL;
}

declare class GCKCastChannel extends NSObject {

	static alloc(): GCKCastChannel; // inherited from NSObject

	static new(): GCKCastChannel; // inherited from NSObject

	readonly isConnected: boolean;

	readonly isWritable: boolean;

	readonly protocolNamespace: string;

	constructor(o: { namespace: string; });

	didChangeWritableState(isWritable: boolean): void;

	didConnect(): void;

	didDisconnect(): void;

	didReceiveTextMessage(message: string): void;

	generateRequestID(): number;

	generateRequestNumber(): number;

	initWithNamespace(protocolNamespace: string): this;

	sendTextMessageError(message: string, error: interop.Pointer | interop.Reference<GCKError>): boolean;
}

declare class GCKCastContext extends NSObject {

	static alloc(): GCKCastContext; // inherited from NSObject

	static isSharedInstanceInitialized(): boolean;

	static new(): GCKCastContext; // inherited from NSObject

	static setSharedInstanceWithOptions(options: GCKCastOptions): void;

	static setSharedInstanceWithOptionsError(options: GCKCastOptions, error: interop.Pointer | interop.Reference<GCKError>): boolean;

	static sharedInstance(): GCKCastContext;

	readonly castState: GCKCastState;

	readonly defaultExpandedMediaControlsViewController: GCKUIExpandedMediaControlsViewController;

	readonly discoveryManager: GCKDiscoveryManager;

	imageCache: GCKUIImageCache;

	imagePicker: GCKUIImagePicker;

	readonly sessionManager: GCKSessionManager;

	useDefaultExpandedMediaControls: boolean;

	clearCastInstructionsShownFlag(): void;

	createCastContainerControllerForViewController(viewController: UIViewController): GCKUICastContainerViewController;

	createMiniMediaControlsViewController(): GCKUIMiniMediaControlsViewController;

	presentCastDialog(): void;

	presentCastInstructionsViewControllerOnce(): boolean;

	presentCastInstructionsViewControllerOnceWithCastButton(castButton: GCKUICastButton): boolean;

	presentDefaultExpandedMediaControls(): void;

	registerDeviceProvider(deviceProvider: GCKDeviceProvider): void;

	unregisterDeviceProviderForCategory(category: string): void;
}

interface GCKCastDeviceStatusListener extends NSObjectProtocol {

	castSessionDidAddMultizoneDevice?(castSession: GCKCastSession, device: GCKMultizoneDevice): void;

	castSessionDidReceiveActiveInputStatus?(castSession: GCKCastSession, activeInputStatus: GCKActiveInputStatus): void;

	castSessionDidReceiveMultizoneStatus?(castSession: GCKCastSession, multizoneStatus: GCKMultizoneStatus): void;

	castSessionDidReceiveStandbyStatus?(castSession: GCKCastSession, standbyStatus: GCKStandbyStatus): void;

	castSessionDidRemoveMultizoneDeviceWithID?(castSession: GCKCastSession, deviceID: string): void;

	castSessionDidUpdateMultizoneDevice?(castSession: GCKCastSession, device: GCKMultizoneDevice): void;
}
declare var GCKCastDeviceStatusListener: {

	prototype: GCKCastDeviceStatusListener;
};

declare class GCKCastOptions extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKCastOptions; // inherited from NSObject

	static new(): GCKCastOptions; // inherited from NSObject

	disableAnalyticsLogging: boolean;

	disableDiscoveryAutostart: boolean;

	launchOptions: GCKLaunchOptions;

	physicalVolumeButtonsWillControlDeviceVolume: boolean;

	sharedContainerIdentifier: string;

	stopReceiverApplicationWhenEndingSession: boolean;

	suspendSessionsWhenBackgrounded: boolean;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { discoveryCriteria: GCKDiscoveryCriteria; });

	constructor(o: { receiverApplicationID: string; });

	constructor(o: { supportedNamespaces: NSArray<string>; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithDiscoveryCriteria(discoveryCriteria: GCKDiscoveryCriteria): this;

	initWithReceiverApplicationID(applicationID: string): this;

	initWithSupportedNamespaces(namespaces: NSArray<string>): this;
}

declare class GCKCastSession extends GCKSession {

	static alloc(): GCKCastSession; // inherited from NSObject

	static new(): GCKCastSession; // inherited from NSObject

	readonly activeInputStatus: GCKActiveInputStatus;

	readonly applicationMetadata: GCKApplicationMetadata;

	readonly standbyStatus: GCKStandbyStatus;

	constructor(o: { device: GCKDevice; sessionID: string; sessionOptions: NSDictionary<string, NSObject>; castOptions: GCKCastOptions; });

	addChannel(channel: GCKCastChannel): boolean;

	addDeviceStatusListener(listener: GCKCastDeviceStatusListener): void;

	initWithDeviceSessionIDSessionOptionsCastOptions(device: GCKDevice, sessionID: string, sessionOptions: NSDictionary<string, NSObject>, castOptions: GCKCastOptions): this;

	removeChannel(channel: GCKCastChannel): boolean;

	removeDeviceStatusListener(listener: GCKCastDeviceStatusListener): void;

	requestMultizoneStatus(): GCKRequest;

	setDeviceMutedForMultizoneDevice(muted: boolean, device: GCKMultizoneDevice): GCKRequest;

	setDeviceVolumeForMultizoneDevice(volume: number, device: GCKMultizoneDevice): GCKRequest;
}

declare const enum GCKCastState {

	NoDevicesAvailable = 0,

	NotConnected = 1,

	Connecting = 2,

	Connected = 3
}

declare class GCKColor extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKColor; // inherited from NSObject

	static black(): GCKColor;

	static blue(): GCKColor;

	static cyan(): GCKColor;

	static green(): GCKColor;

	static magenta(): GCKColor;

	static new(): GCKColor; // inherited from NSObject

	static red(): GCKColor;

	static white(): GCKColor;

	static yellow(): GCKColor;

	readonly alpha: number;

	readonly blue: number;

	readonly green: number;

	readonly red: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { CGColor: any; });

	constructor(o: { CGColor: any; alpha: number; });

	constructor(o: { CSSString: string; });

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { red: number; green: number; blue: number; });

	constructor(o: { red: number; green: number; blue: number; alpha: number; });

	constructor(o: { UIColor: UIColor; });

	CSSString(): string;

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCGColor(color: any): this;

	initWithCGColorAlpha(color: any, alpha: number): this;

	initWithCSSString(CSSString: string): this;

	initWithCoder(aDecoder: NSCoder): this;

	initWithRedGreenBlue(red: number, green: number, blue: number): this;

	initWithRedGreenBlueAlpha(red: number, green: number, blue: number, alpha: number): this;

	initWithUIColor(color: UIColor): this;
}

declare const enum GCKConnectionState {

	Disconnected = 0,

	Connecting = 1,

	Connected = 2,

	Disconnecting = 3
}

declare const enum GCKConnectionSuspendReason {

	Unknown = -1,

	None = 0,

	AppBackgrounded = 1,

	NetworkError = 2,

	NetworkNotReachable = 3,

	AppTerminated = 4
}

declare class GCKDevice extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKDevice; // inherited from NSObject

	static deviceCategoryForDeviceUniqueID(deviceUniqueID: string): string;

	static new(): GCKDevice; // inherited from NSObject

	readonly category: string;

	readonly deviceID: string;

	deviceVersion: string;

	friendlyName: string;

	icons: NSArray<GCKImage>;

	readonly ipAddress: string;

	readonly isOnLocalNetwork: boolean;

	modelName: string;

	readonly networkAddress: GCKNetworkAddress;

	readonly servicePort: number;

	status: GCKDeviceStatus;

	statusText: string;

	readonly type: GCKDeviceType;

	readonly uniqueID: string;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	attributeForKey(key: string): NSObject;

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	hasCapabilities(deviceCapabilities: number): boolean;

	initWithCoder(aDecoder: NSCoder): this;

	isSameDeviceAs(other: GCKDevice): boolean;

	removeAllAttributes(): void;

	removeAttributeForKey(key: string): void;

	setAttributeForKey(attribute: NSObject, key: string): void;
}

declare const enum GCKDeviceCapability {

	VideoOut = 1,

	VideoIn = 2,

	AudioOut = 4,

	AudioIn = 8,

	MultizoneGroup = 32,

	MasterOrFixedVolume = 2048,

	AttenuationOrFixedVolume = 4096
}

declare class GCKDeviceProvider extends NSObject {

	static alloc(): GCKDeviceProvider; // inherited from NSObject

	static new(): GCKDeviceProvider; // inherited from NSObject

	readonly deviceCategory: string;

	readonly devices: NSArray<GCKDevice>;

	passiveScan: boolean;

	constructor(o: { deviceCategory: string; });

	createDeviceWithIDIpAddressServicePort(deviceID: string, ipAddress: string, servicePort: number): GCKDevice;

	createDeviceWithIDNetworkAddressServicePort(deviceID: string, networkAddress: GCKNetworkAddress, servicePort: number): GCKDevice;

	createSessionForDeviceSessionID(device: GCKDevice, sessionID: string): GCKSession;

	createSessionForDeviceSessionIDSessionOptions(device: GCKDevice, sessionID: string, sessionOptions: NSDictionary<string, NSObject>): GCKSession;

	initWithDeviceCategory(deviceCategory: string): this;

	notifyDidPublishDevice(device: GCKDevice): void;

	notifyDidStartDiscovery(): void;

	notifyDidUnpublishDevice(device: GCKDevice): void;

	notifyDidUpdateDevice(device: GCKDevice): void;

	startDiscovery(): void;

	stopDiscovery(): void;
}

declare const enum GCKDeviceStatus {

	Unknown = -1,

	Idle = 0,

	Busy = 1
}

declare const enum GCKDeviceType {

	Generic = 0,

	TV = 1,

	Speaker = 2,

	SpeakerGroup = 3,

	NearbyUnpaired = 4
}

declare class GCKDiscoveryCriteria extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKDiscoveryCriteria; // inherited from NSObject

	static new(): GCKDiscoveryCriteria; // inherited from NSObject

	readonly allSubtypes: NSSet<string>;

	readonly applicationIDs: NSOrderedSet<string>;

	readonly hasApplicationIDs: boolean;

	readonly hasNamespaces: boolean;

	readonly namespaces: NSSet<string>;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { applicationID: string; });

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { namespaces: NSSet<string>; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithApplicationID(applicationID: string): this;

	initWithCoder(aDecoder: NSCoder): this;

	initWithNamespaces(namespaces: NSSet<string>): this;
}

declare class GCKDiscoveryManager extends NSObject {

	static alloc(): GCKDiscoveryManager; // inherited from NSObject

	static new(): GCKDiscoveryManager; // inherited from NSObject

	readonly deviceCount: number;

	readonly discoveryActive: boolean;

	readonly discoveryState: GCKDiscoveryState;

	readonly hasDiscoveredDevices: boolean;

	passiveScan: boolean;

	addListener(listener: GCKDiscoveryManagerListener): void;

	cancelFindOperation(): void;

	deviceAtIndex(index: number): GCKDevice;

	deviceWithUniqueID(uniqueID: string): GCKDevice;

	findDeviceWithUniqueIDTimeoutCompletion(uniqueID: string, timeout: number, completion: (p1: GCKDevice) => void): void;

	isDiscoveryActiveForDeviceCategory(deviceCategory: string): boolean;

	removeListener(listener: GCKDiscoveryManagerListener): void;

	startDiscovery(): void;

	stopDiscovery(): void;
}

interface GCKDiscoveryManagerListener extends NSObjectProtocol {

	didInsertDeviceAtIndex?(device: GCKDevice, index: number): void;

	didRemoveDeviceAtIndex?(index: number): void;

	didRemoveDeviceAtIndex?(device: GCKDevice, index: number): void;

	didStartDiscoveryForDeviceCategory?(deviceCategory: string): void;

	didUpdateDeviceAtIndex?(device: GCKDevice, index: number): void;

	didUpdateDeviceAtIndexAndMoveToIndex?(device: GCKDevice, index: number, newIndex: number): void;

	didUpdateDeviceList?(): void;

	willUpdateDeviceList?(): void;
}
declare var GCKDiscoveryManagerListener: {

	prototype: GCKDiscoveryManagerListener;
};

declare const enum GCKDiscoveryState {

	Stopped = 0,

	Running = 1
}

declare class GCKError extends NSError {

	static alloc(): GCKError; // inherited from NSObject

	static enumDescriptionForCode(code: GCKErrorCode): string;

	static errorWithCode(code: GCKErrorCode): GCKError;

	static errorWithCodeCustomData(code: GCKErrorCode, customData: any): GCKError;

	static errorWithDomainCodeUserInfo(domain: string, code: number, dict: NSDictionary<string, any>): GCKError; // inherited from NSError

	static fileProviderErrorForCollisionWithItem(existingItem: NSFileProviderItem): GCKError; // inherited from NSError

	static fileProviderErrorForNonExistentItemWithIdentifier(itemIdentifier: string): GCKError; // inherited from NSError

	static new(): GCKError; // inherited from NSObject
}

declare const enum GCKErrorCode {

	NoError = 0,

	NetworkError = 1,

	Timeout = 2,

	DeviceAuthenticationFailure = 3,

	InvalidRequest = 4,

	Cancelled = 5,

	Replaced = 6,

	NotAllowed = 7,

	DuplicateRequest = 8,

	InvalidState = 9,

	SendBufferFull = 10,

	MessageTooBig = 11,

	ChannelNotConnected = 12,

	DeviceAuthorizationFailure = 13,

	DeviceNotConnected = 14,

	ProtocolVersionMismatch = 15,

	MaxUsersConnected = 16,

	NetworkNotReachable = 17,

	ProtocolError = 18,

	AlreadyInitialized = 19,

	ApplicationNotFound = 20,

	ApplicationNotRunning = 21,

	InvalidApplicationSessionID = 22,

	SecureTransportError = 23,

	SocketAlreadyConnected = 24,

	SocketInvalidAddress = 25,

	SocketInvalidParameter = 26,

	MediaLoadFailed = 30,

	InvalidMediaPlayerState = 31,

	NoMediaSession = 32,

	AuthenticationErrorReceived = 40,

	MalformedClientCertificate = 41,

	NotX509Certificate = 42,

	DeviceCertificateNotTrusted = 43,

	SSLCertificateNotTrusted = 44,

	MalformedAuthenticationResponse = 45,

	DeviceCapabilityNotSupported = 46,

	CRLInvalid = 47,

	CRLCheckFailed = 48,

	BroadcastMessageEncryptionFailed = 50,

	BroadcastKeyExchangeInvalidResponse = 51,

	BroadcastKeyExchangeInvalidInput = 52,

	BroadcastKeyExchangeEmptyResponse = 53,

	BroadcastKeyExchangeRequestTimeout = 54,

	BroadcastKeyExchangeFailedToFindDevice = 55,

	BroadcastKeyExchangeFailedToConnect = 56,

	BroadcastMessageDropped = 57,

	BroadcastSocketError = 58,

	BroadcastFailedToGenerateEncryptionKey = 59,

	GuestModeListenFailed = 60,

	RemoteDisplayError = 80,

	RemoteDisplayDeviceNotSupported = 81,

	RemoteDisplayFeatureNotSupported = 82,

	RemoteDisplayConfigurationRejectedByReceiver = 83,

	RemoteDisplayOpenGLError = 84,

	RemoteDisplayMetalError = 85,

	RemoteDisplayAudioConversionError = 86,

	AppDidEnterBackground = 91,

	Disconnected = 92,

	UnsupportedFeature = 93,

	Unknown = 99
}

declare class GCKGenericChannel extends GCKCastChannel {

	static alloc(): GCKGenericChannel; // inherited from NSObject

	static new(): GCKGenericChannel; // inherited from NSObject

	delegate: GCKGenericChannelDelegate;
}

interface GCKGenericChannelDelegate extends NSObjectProtocol {

	castChannelDidChangeWritableState?(channel: GCKCastChannel, writable: boolean): void;

	castChannelDidConnect?(channel: GCKGenericChannel): void;

	castChannelDidDisconnect?(channel: GCKGenericChannel): void;

	castChannelDidReceiveTextMessageWithNamespace(channel: GCKGenericChannel, message: string, protocolNamespace: string): void;
}
declare var GCKGenericChannelDelegate: {

	prototype: GCKGenericChannelDelegate;
};

declare const enum GCKHLSSegmentFormat {

	Undefined = 0,

	AAC = 1,

	AC3 = 2,

	MP3 = 3,

	TS = 4,

	TS_AAC = 5
}

declare class GCKImage extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKImage; // inherited from NSObject

	static new(): GCKImage; // inherited from NSObject

	readonly URL: NSURL;

	readonly height: number;

	readonly width: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { URL: NSURL; width: number; height: number; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithURLWidthHeight(URL: NSURL, width: number, height: number): this;
}

declare function GCKIsValidTimeInterval(timeInterval: number): boolean;

declare class GCKJSONUtils extends NSObject {

	static alloc(): GCKJSONUtils; // inherited from NSObject

	static isJSONObjectEquivalentTo(actual: any, expected: any): boolean;

	static isJSONStringEquivalentTo(actual: string, expected: string): boolean;

	static new(): GCKJSONUtils; // inherited from NSObject

	static parseJSON(json: string): any;

	static parseJSONError(json: string): any;

	static writeJSON(object: any): string;
}

declare class GCKLaunchOptions extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKLaunchOptions; // inherited from NSObject

	static new(): GCKLaunchOptions; // inherited from NSObject

	languageCode: string;

	relaunchIfRunning: boolean;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { languageCode: string; relaunchIfRunning: boolean; });

	constructor(o: { relaunchIfRunning: boolean; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithLanguageCodeRelaunchIfRunning(languageCode: string, relaunchIfRunning: boolean): this;

	initWithRelaunchIfRunning(relaunchIfRunning: boolean): this;
}

declare class GCKLogger extends NSObject {

	static alloc(): GCKLogger; // inherited from NSObject

	static new(): GCKLogger; // inherited from NSObject

	static sharedInstance(): GCKLogger;

	consoleLoggingEnabled: boolean;

	delegate: GCKLoggerDelegate;

	fileLoggingEnabled: boolean;

	filter: GCKLoggerFilter;

	loggingEnabled: boolean;

	maxLogFileCount: number;

	maxLogFileSize: number;

	minimumLevel: GCKLoggerLevel;
}

interface GCKLoggerDelegate extends NSObjectProtocol {

	logMessageAtLevelFromFunctionLocation?(message: string, level: GCKLoggerLevel, _function: string, location: string): void;

	logMessageFromFunction?(message: string, _function: string): void;
}
declare var GCKLoggerDelegate: {

	prototype: GCKLoggerDelegate;
};

declare class GCKLoggerFilter extends NSObject {

	static alloc(): GCKLoggerFilter; // inherited from NSObject

	static new(): GCKLoggerFilter; // inherited from NSObject

	exclusive: boolean;

	minimumLevel: GCKLoggerLevel;

	addClassNames(classNames: NSArray<string>): void;

	addClassNamesMinimumLogLevel(classNames: NSArray<string>, minimumLogLevel: GCKLoggerLevel): void;

	addFunctionNames(functionNames: NSArray<string>): void;

	addFunctionNamesMinimumLogLevel(functionNames: NSArray<string>, minimumLogLevel: GCKLoggerLevel): void;

	addMessagePatterns(messagePatterns: NSArray<string>): void;

	addMessagePatternsCaseInsensitive(messagePatterns: NSArray<string>, caseInsensitive: boolean): void;

	reset(): void;

	setLoggingLevelForClasses(minimumLevel: GCKLoggerLevel, classNames: NSArray<string>): void;

	setLoggingLevelForFunctions(minimumLevel: GCKLoggerLevel, functionNames: NSArray<string>): void;
}

declare const enum GCKLoggerLevel {

	None = 0,

	Verbose = 1,

	Debug = 2,

	Info = 3,

	Warning = 4,

	Error = 5,

	Assert = 6
}

declare class GCKMediaInformation extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMediaInformation; // inherited from NSObject

	static new(): GCKMediaInformation; // inherited from NSObject

	readonly adBreakClips: NSArray<GCKAdBreakClipInfo>;

	readonly adBreaks: NSArray<GCKAdBreakInfo>;

	readonly contentID: string;

	readonly contentType: string;

	readonly customData: any;

	readonly entity: string;

	readonly mediaTracks: NSArray<GCKMediaTrack>;

	readonly metadata: GCKMediaMetadata;

	readonly streamDuration: number;

	readonly streamType: GCKMediaStreamType;

	readonly textTrackStyle: GCKMediaTextTrackStyle;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { contentID: string; streamType: GCKMediaStreamType; contentType: string; metadata: GCKMediaMetadata; adBreaks: NSArray<GCKAdBreakInfo>; adBreakClips: NSArray<GCKAdBreakClipInfo>; streamDuration: number; mediaTracks: NSArray<GCKMediaTrack>; textTrackStyle: GCKMediaTextTrackStyle; customData: any; });

	constructor(o: { contentID: string; streamType: GCKMediaStreamType; contentType: string; metadata: GCKMediaMetadata; streamDuration: number; mediaTracks: NSArray<GCKMediaTrack>; textTrackStyle: GCKMediaTextTrackStyle; customData: any; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithContentIDStreamTypeContentTypeMetadataAdBreaksAdBreakClipsStreamDurationMediaTracksTextTrackStyleCustomData(contentID: string, streamType: GCKMediaStreamType, contentType: string, metadata: GCKMediaMetadata, adBreaks: NSArray<GCKAdBreakInfo>, adBreakClips: NSArray<GCKAdBreakClipInfo>, streamDuration: number, mediaTracks: NSArray<GCKMediaTrack>, textTrackStyle: GCKMediaTextTrackStyle, customData: any): this;

	initWithContentIDStreamTypeContentTypeMetadataStreamDurationMediaTracksTextTrackStyleCustomData(contentID: string, streamType: GCKMediaStreamType, contentType: string, metadata: GCKMediaMetadata, streamDuration: number, mediaTracks: NSArray<GCKMediaTrack>, textTrackStyle: GCKMediaTextTrackStyle, customData: any): this;

	mediaTrackWithID(trackID: number): GCKMediaTrack;
}

declare class GCKMediaInformationBuilder extends NSObject {

	static alloc(): GCKMediaInformationBuilder; // inherited from NSObject

	static new(): GCKMediaInformationBuilder; // inherited from NSObject

	adBreakClips: NSArray<GCKAdBreakClipInfo>;

	adBreaks: NSArray<GCKAdBreakInfo>;

	contentID: string;

	contentType: string;

	customData: any;

	entity: string;

	mediaTracks: NSArray<GCKMediaTrack>;

	metadata: GCKMediaMetadata;

	streamDuration: number;

	streamType: GCKMediaStreamType;

	textTrackStyle: GCKMediaTextTrackStyle;

	constructor(o: { contentID: string; });

	constructor(o: { contentID: string; entity: string; });

	constructor(o: { entity: string; });

	constructor(o: { mediaInformation: GCKMediaInformation; });

	build(): GCKMediaInformation;

	initWithContentID(contentID: string): this;

	initWithContentIDEntity(contentID: string, entity: string): this;

	initWithEntity(entity: string): this;

	initWithMediaInformation(mediaInfo: GCKMediaInformation): this;
}

declare class GCKMediaLoadOptions extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMediaLoadOptions; // inherited from NSObject

	static new(): GCKMediaLoadOptions; // inherited from NSObject

	activeTrackIDs: NSArray<number>;

	autoplay: boolean;

	credentials: string;

	credentialsType: string;

	customData: any;

	playPosition: number;

	playbackRate: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;
}

declare class GCKMediaMetadata extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMediaMetadata; // inherited from NSObject

	static new(): GCKMediaMetadata; // inherited from NSObject

	readonly metadataType: GCKMediaMetadataType;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { metadataType: GCKMediaMetadataType; });

	addImage(image: GCKImage): void;

	allKeys(): NSArray<string>;

	containsKey(key: string): boolean;

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	dateAsStringForKey(key: string): string;

	dateForKey(key: string): Date;

	doubleForKey(key: string): number;

	doubleForKeyDefaultValue(key: string, defaultValue: number): number;

	encodeWithCoder(aCoder: NSCoder): void;

	images(): NSArray<any>;

	initWithCoder(aDecoder: NSCoder): this;

	initWithMetadataType(metadataType: GCKMediaMetadataType): this;

	integerForKey(key: string): number;

	integerForKeyDefaultValue(key: string, defaultValue: number): number;

	objectForKey(key: string): any;

	removeAllMediaImages(): void;

	setDateForKey(date: Date, key: string): void;

	setDoubleForKey(value: number, key: string): void;

	setIntegerForKey(value: number, key: string): void;

	setStringForKey(value: string, key: string): void;

	stringForKey(key: string): string;
}

declare const enum GCKMediaMetadataImageType {

	Custom = 0,

	CastDialog = 1,

	MiniController = 2,

	Background = 3
}

declare const enum GCKMediaMetadataType {

	Generic = 0,

	Movie = 1,

	TVShow = 2,

	MusicTrack = 3,

	Photo = 4,

	User = 100
}

declare const enum GCKMediaPlayerIdleReason {

	None = 0,

	Finished = 1,

	Cancelled = 2,

	Interrupted = 3,

	Error = 4
}

declare const enum GCKMediaPlayerState {

	Unknown = 0,

	Idle = 1,

	Playing = 2,

	Paused = 3,

	Buffering = 4,

	Loading = 5
}

declare class GCKMediaQueueItem extends NSObject implements NSCopying {

	static alloc(): GCKMediaQueueItem; // inherited from NSObject

	static new(): GCKMediaQueueItem; // inherited from NSObject

	readonly activeTrackIDs: NSArray<number>;

	readonly autoplay: boolean;

	readonly customData: any;

	readonly itemID: number;

	readonly mediaInformation: GCKMediaInformation;

	readonly playbackDuration: number;

	readonly preloadTime: number;

	readonly startTime: number;

	constructor(o: { mediaInformation: GCKMediaInformation; autoplay: boolean; startTime: number; playbackDuration: number; preloadTime: number; activeTrackIDs: NSArray<number>; customData: any; });

	constructor(o: { mediaInformation: GCKMediaInformation; autoplay: boolean; startTime: number; preloadTime: number; activeTrackIDs: NSArray<number>; customData: any; });

	clearItemID(): void;

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	initWithMediaInformationAutoplayStartTimePlaybackDurationPreloadTimeActiveTrackIDsCustomData(mediaInformation: GCKMediaInformation, autoplay: boolean, startTime: number, playbackDuration: number, preloadTime: number, activeTrackIDs: NSArray<number>, customData: any): this;

	initWithMediaInformationAutoplayStartTimePreloadTimeActiveTrackIDsCustomData(mediaInformation: GCKMediaInformation, autoplay: boolean, startTime: number, preloadTime: number, activeTrackIDs: NSArray<number>, customData: any): this;

	mediaQueueItemModifiedWithBlock(block: (p1: GCKMediaQueueItemBuilder) => void): this;
}

declare class GCKMediaQueueItemBuilder extends NSObject {

	static alloc(): GCKMediaQueueItemBuilder; // inherited from NSObject

	static new(): GCKMediaQueueItemBuilder; // inherited from NSObject

	activeTrackIDs: NSArray<number>;

	autoplay: boolean;

	customData: any;

	mediaInformation: GCKMediaInformation;

	playbackDuration: number;

	preloadTime: number;

	startTime: number;

	constructor(o: { mediaQueueItem: GCKMediaQueueItem; });

	build(): GCKMediaQueueItem;

	initWithMediaQueueItem(item: GCKMediaQueueItem): this;
}

declare class GCKMediaQueueLoadOptions extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMediaQueueLoadOptions; // inherited from NSObject

	static new(): GCKMediaQueueLoadOptions; // inherited from NSObject

	customData: any;

	playPosition: number;

	repeatMode: GCKMediaRepeatMode;

	startIndex: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;
}

declare const enum GCKMediaRepeatMode {

	Unchanged = 0,

	Off = 1,

	Single = 2,

	All = 3,

	AllAndShuffle = 4
}

declare class GCKMediaRequestItem extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMediaRequestItem; // inherited from NSObject

	static mapHLSSegmentFormatStringToEnum(hlsSegmentFormatString: string): GCKHLSSegmentFormat;

	static mapHLSSegmentFormatToString(hlsSegmentFormat: GCKHLSSegmentFormat): string;

	static new(): GCKMediaRequestItem; // inherited from NSObject

	hlsSegmentFormat: GCKHLSSegmentFormat;

	initialTime: number;

	mediaURL: NSURL;

	protocolType: GCKStreamingProtocolType;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { URL: NSURL; protocolType: GCKStreamingProtocolType; });

	constructor(o: { URL: NSURL; protocolType: GCKStreamingProtocolType; initialTime: number; hlsSegmentFormat: GCKHLSSegmentFormat; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithURLProtocolType(url: NSURL, protocolType: GCKStreamingProtocolType): this;

	initWithURLProtocolTypeInitialTimeHlsSegmentFormat(url: NSURL, protocolType: GCKStreamingProtocolType, initialTime: number, hlsSegmentFormat: GCKHLSSegmentFormat): this;
}

declare const enum GCKMediaResumeState {

	Unchanged = 0,

	Play = 1,

	Pause = 2
}

declare class GCKMediaSeekOptions extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMediaSeekOptions; // inherited from NSObject

	static new(): GCKMediaSeekOptions; // inherited from NSObject

	customData: any;

	interval: number;

	relative: boolean;

	resumeState: GCKMediaResumeState;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;
}

declare class GCKMediaStatus extends NSObject implements NSCopying {

	static alloc(): GCKMediaStatus; // inherited from NSObject

	static new(): GCKMediaStatus; // inherited from NSObject

	readonly activeTrackIDs: NSArray<number>;

	readonly adBreakStatus: GCKAdBreakStatus;

	readonly currentItemID: number;

	readonly currentQueueItem: GCKMediaQueueItem;

	readonly customData: any;

	readonly idleReason: GCKMediaPlayerIdleReason;

	readonly isMuted: boolean;

	readonly loadingItemID: number;

	readonly mediaInformation: GCKMediaInformation;

	readonly mediaSessionID: number;

	readonly nextQueueItem: GCKMediaQueueItem;

	readonly playbackRate: number;

	readonly playerState: GCKMediaPlayerState;

	readonly playingAd: boolean;

	readonly preloadedItemID: number;

	readonly queueHasCurrentItem: boolean;

	readonly queueHasLoadingItem: boolean;

	readonly queueHasPreviousItem: boolean;

	readonly queueRepeatMode: GCKMediaRepeatMode;

	readonly streamPosition: number;

	readonly videoInfo: GCKVideoInfo;

	readonly volume: number;

	constructor(o: { sessionID: number; mediaInformation: GCKMediaInformation; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	initWithSessionIDMediaInformation(mediaSessionID: number, mediaInformation: GCKMediaInformation): this;

	isMediaCommandSupported(command: number): boolean;

	queueHasNextItem(): boolean;

	queueIndexForItemID(itemID: number): number;

	queueItemAtIndex(index: number): GCKMediaQueueItem;

	queueItemCount(): number;

	queueItemWithItemID(itemID: number): GCKMediaQueueItem;
}

declare const enum GCKMediaStreamType {

	None = 0,

	Buffered = 1,

	Live = 2,

	Unknown = 99
}

declare class GCKMediaTextTrackStyle extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMediaTextTrackStyle; // inherited from NSObject

	static createDefault(): GCKMediaTextTrackStyle;

	static new(): GCKMediaTextTrackStyle; // inherited from NSObject

	backgroundColor: GCKColor;

	customData: any;

	edgeColor: GCKColor;

	edgeType: GCKMediaTextTrackStyleEdgeType;

	fontFamily: string;

	fontGenericFamily: GCKMediaTextTrackStyleFontGenericFamily;

	fontScale: number;

	fontStyle: GCKMediaTextTrackStyleFontStyle;

	foregroundColor: GCKColor;

	windowColor: GCKColor;

	windowRoundedCornerRadius: number;

	windowType: GCKMediaTextTrackStyleWindowType;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;
}

declare const enum GCKMediaTextTrackStyleEdgeType {

	Unknown = -1,

	None = 0,

	Outline = 1,

	DropShadow = 2,

	Raised = 3,

	Depressed = 4
}

declare const enum GCKMediaTextTrackStyleFontGenericFamily {

	Unknown = -1,

	None = 0,

	SansSerif = 1,

	MonospacedSansSerif = 2,

	Serif = 3,

	MonospacedSerif = 4,

	Casual = 5,

	Cursive = 6,

	SmallCapitals = 7
}

declare const enum GCKMediaTextTrackStyleFontStyle {

	Unknown = -1,

	Normal = 0,

	Bold = 1,

	Italic = 2,

	BoldItalic = 3
}

declare const enum GCKMediaTextTrackStyleWindowType {

	Unknown = -1,

	None = 0,

	Normal = 1,

	RoundedCorners = 2
}

declare const enum GCKMediaTextTrackSubtype {

	Unknown = 0,

	Subtitles = 1,

	Captions = 3,

	Descriptions = 4,

	Chapters = 5,

	Metadata = 6
}

declare class GCKMediaTrack extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMediaTrack; // inherited from NSObject

	static new(): GCKMediaTrack; // inherited from NSObject

	readonly contentIdentifier: string;

	readonly contentType: string;

	readonly customData: any;

	readonly identifier: number;

	readonly languageCode: string;

	readonly name: string;

	readonly textSubtype: GCKMediaTextTrackSubtype;

	readonly type: GCKMediaTrackType;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { identifier: number; contentIdentifier: string; contentType: string; type: GCKMediaTrackType; textSubtype: GCKMediaTextTrackSubtype; name: string; languageCode: string; customData: any; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithIdentifierContentIdentifierContentTypeTypeTextSubtypeNameLanguageCodeCustomData(identifier: number, contentIdentifier: string, contentType: string, type: GCKMediaTrackType, textSubtype: GCKMediaTextTrackSubtype, name: string, languageCode: string, customData: any): this;
}

declare const enum GCKMediaTrackType {

	Unknown = 0,

	Text = 1,

	Audio = 2,

	Video = 3
}

declare class GCKMultizoneDevice extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMultizoneDevice; // inherited from NSObject

	static new(): GCKMultizoneDevice; // inherited from NSObject

	capabilities: number;

	readonly deviceID: string;

	readonly friendlyName: string;

	muted: boolean;

	volumeLevel: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { deviceID: string; friendlyName: string; capabilities: number; volumeLevel: number; muted: boolean; });

	constructor(o: { JSONObject: any; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithDeviceIDFriendlyNameCapabilitiesVolumeLevelMuted(deviceID: string, friendlyName: string, capabilities: number, volume: number, muted: boolean): this;

	initWithJSONObject(JSONObject: any): this;
}

declare class GCKMultizoneStatus extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKMultizoneStatus; // inherited from NSObject

	static new(): GCKMultizoneStatus; // inherited from NSObject

	devices: NSArray<GCKMultizoneDevice>;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { devices: NSArray<GCKMultizoneDevice>; });

	constructor(o: { JSONObject: any; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithDevices(devices: NSArray<GCKMultizoneDevice>): this;

	initWithJSONObject(JSONObject: any): this;
}

declare class GCKNetworkAddress extends NSObject implements NSCoding, NSCopying {

	static IPv4BroadcastAddress(): GCKNetworkAddress;

	static addressWithIPCPath(path: string): GCKNetworkAddress;

	static addressWithIPv4Address(ipAddress: string): GCKNetworkAddress;

	static addressWithIPv6Address(ipAddress: string): GCKNetworkAddress;

	static alloc(): GCKNetworkAddress; // inherited from NSObject

	static loopbackAddressOfType(type: GCKNetworkAddressType): GCKNetworkAddress;

	static new(): GCKNetworkAddress; // inherited from NSObject

	static wildcardAddressOfType(type: GCKNetworkAddressType): GCKNetworkAddress;

	readonly addressData: NSData;

	readonly ipAddress: string;

	readonly type: GCKNetworkAddressType;

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	constructor(o: { type: GCKNetworkAddressType; addressData: NSData; });

	constructor(o: { type: GCKNetworkAddressType; ipAddress: string; });

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;

	initWithTypeAddressData(type: GCKNetworkAddressType, addressData: NSData): this;

	initWithTypeIpAddress(type: GCKNetworkAddressType, ipAddress: string): this;
}

declare const enum GCKNetworkAddressType {

	Unknown = 0,

	IPv4 = 1,

	IPv6 = 2,

	IPC = 3
}

declare class GCKOpenURLOptions extends NSObject implements NSCopying, NSSecureCoding {

	static alloc(): GCKOpenURLOptions; // inherited from NSObject

	static new(): GCKOpenURLOptions; // inherited from NSObject

	static openURLOptionsFromURL(url: NSURL): GCKOpenURLOptions;

	deviceFriendlyName: string;

	deviceUniqueID: string;

	sessionID: string;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

	constructor(o: { coder: NSCoder; }); // inherited from NSCoding

	asURLQueryItem(): NSURLQueryItem;

	copyWithZone(zone: interop.Pointer | interop.Reference<any>): any;

	encodeWithCoder(aCoder: NSCoder): void;

	initWithCoder(aDecoder: NSCoder): this;
}

declare class GCKRemoteMediaClient extends NSObject {

	static alloc(): GCKRemoteMediaClient; // inherited from NSObject

	static new(): GCKRemoteMediaClient; // inherited from NSObject

	adInfoParserDelegate: GCKRemoteMediaClientAdInfoParserDelegate;

	readonly connected: boolean;

	readonly mediaStatus: GCKMediaStatus;

	readonly timeSinceLastMediaStatusUpdate: number;

	addListener(listener: GCKRemoteMediaClientListener): void;

	approximateStreamPosition(): number;

	loadMedia(mediaInfo: GCKMediaInformation): GCKRequest;

	loadMediaAutoplay(mediaInfo: GCKMediaInformation, autoplay: boolean): GCKRequest;

	loadMediaAutoplayPlayPosition(mediaInfo: GCKMediaInformation, autoplay: boolean, playPosition: number): GCKRequest;

	loadMediaAutoplayPlayPositionActiveTrackIDs(mediaInfo: GCKMediaInformation, autoplay: boolean, playPosition: number, activeTrackIDs: NSArray<number>): GCKRequest;

	loadMediaAutoplayPlayPositionActiveTrackIDsCustomData(mediaInfo: GCKMediaInformation, autoplay: boolean, playPosition: number, activeTrackIDs: NSArray<number>, customData: any): GCKRequest;

	loadMediaAutoplayPlayPositionCustomData(mediaInfo: GCKMediaInformation, autoplay: boolean, playPosition: number, customData: any): GCKRequest;

	loadMediaWithOptions(mediaInfo: GCKMediaInformation, options: GCKMediaLoadOptions): GCKRequest;

	notifyDidInsertQueueItemsWithIDsBeforeItemWithID(itemIDs: NSArray<number>, beforeItemID: number): void;

	notifyDidReceiveQueueItemIDs(itemIDs: NSArray<number>): void;

	notifyDidReceiveQueueItems(items: NSArray<GCKMediaQueueItem>): void;

	notifyDidRemoveQueueItemsWithIDs(itemIDs: NSArray<number>): void;

	notifyDidStartMediaSession(): void;

	notifyDidUpdateMediaStatus(): void;

	notifyDidUpdateMetadata(): void;

	notifyDidUpdatePreloadStatus(): void;

	notifyDidUpdateQueue(): void;

	notifyDidUpdateQueueItemsWithIDs(itemIDs: NSArray<number>): void;

	pause(): GCKRequest;

	pauseWithCustomData(customData: any): GCKRequest;

	play(): GCKRequest;

	playWithCustomData(customData: any): GCKRequest;

	queueFetchItemIDs(): GCKRequest;

	queueFetchItemsForIDs(queueItemIDs: NSArray<number>): GCKRequest;

	queueInsertAndPlayItemBeforeItemWithID(item: GCKMediaQueueItem, beforeItemID: number): GCKRequest;

	queueInsertAndPlayItemBeforeItemWithIDPlayPositionCustomData(item: GCKMediaQueueItem, beforeItemID: number, playPosition: number, customData: any): GCKRequest;

	queueInsertItemBeforeItemWithID(item: GCKMediaQueueItem, beforeItemID: number): GCKRequest;

	queueInsertItemsBeforeItemWithID(queueItems: NSArray<GCKMediaQueueItem>, beforeItemID: number): GCKRequest;

	queueInsertItemsBeforeItemWithIDCustomData(queueItems: NSArray<GCKMediaQueueItem>, beforeItemID: number, customData: any): GCKRequest;

	queueJumpToItemWithID(itemID: number): GCKRequest;

	queueJumpToItemWithIDCustomData(itemID: number, customData: any): GCKRequest;

	queueJumpToItemWithIDPlayPositionCustomData(itemID: number, playPosition: number, customData: any): GCKRequest;

	queueLoadItemsStartIndexPlayPositionRepeatModeCustomData(queueItems: NSArray<GCKMediaQueueItem>, startIndex: number, playPosition: number, repeatMode: GCKMediaRepeatMode, customData: any): GCKRequest;

	queueLoadItemsStartIndexRepeatMode(queueItems: NSArray<GCKMediaQueueItem>, startIndex: number, repeatMode: GCKMediaRepeatMode): GCKRequest;

	queueLoadItemsStartIndexRepeatModeCustomData(queueItems: NSArray<GCKMediaQueueItem>, startIndex: number, repeatMode: GCKMediaRepeatMode, customData: any): GCKRequest;

	queueLoadItemsWithOptions(queueItems: NSArray<GCKMediaQueueItem>, options: GCKMediaQueueLoadOptions): GCKRequest;

	queueMoveItemWithIDBeforeItemWithID(itemID: number, beforeItemID: number): GCKRequest;

	queueNextItem(): GCKRequest;

	queuePreviousItem(): GCKRequest;

	queueRemoveItemWithID(itemID: number): GCKRequest;

	queueRemoveItemsWithIDs(itemIDs: NSArray<number>): GCKRequest;

	queueRemoveItemsWithIDsCustomData(itemIDs: NSArray<number>, customData: any): GCKRequest;

	queueReorderItemsWithIDsInsertBeforeItemWithID(queueItemIDs: NSArray<number>, beforeItemID: number): GCKRequest;

	queueReorderItemsWithIDsInsertBeforeItemWithIDCustomData(queueItemIDs: NSArray<number>, beforeItemID: number, customData: any): GCKRequest;

	queueSetRepeatMode(repeatMode: GCKMediaRepeatMode): GCKRequest;

	queueUpdateItems(queueItems: NSArray<GCKMediaQueueItem>): GCKRequest;

	queueUpdateItemsCustomData(queueItems: NSArray<GCKMediaQueueItem>, customData: any): GCKRequest;

	removeListener(listener: GCKRemoteMediaClientListener): void;

	requestStatus(): GCKRequest;

	seekToTimeInterval(position: number): GCKRequest;

	seekToTimeIntervalResumeState(position: number, resumeState: GCKMediaResumeState): GCKRequest;

	seekToTimeIntervalResumeStateCustomData(position: number, resumeState: GCKMediaResumeState, customData: any): GCKRequest;

	seekWithOptions(options: GCKMediaSeekOptions): GCKRequest;

	setActiveTrackIDs(activeTrackIDs: NSArray<number>): GCKRequest;

	setPlaybackRate(playbackRate: number): GCKRequest;

	setPlaybackRateCustomData(playbackRate: number, customData: any): GCKRequest;

	setStreamMuted(muted: boolean): GCKRequest;

	setStreamMutedCustomData(muted: boolean, customData: any): GCKRequest;

	setStreamVolume(volume: number): GCKRequest;

	setStreamVolumeCustomData(volume: number, customData: any): GCKRequest;

	setTextTrackStyle(textTrackStyle: GCKMediaTextTrackStyle): GCKRequest;

	skipAd(): GCKRequest;

	stop(): GCKRequest;

	stopWithCustomData(customData: any): GCKRequest;
}

interface GCKRemoteMediaClientAdInfoParserDelegate extends NSObjectProtocol {

	remoteMediaClientShouldSetAdBreaksInMediaStatus?(client: GCKRemoteMediaClient, mediaStatus: GCKMediaStatus): NSArray<GCKAdBreakInfo>;

	remoteMediaClientShouldSetPlayingAdInMediaStatus?(client: GCKRemoteMediaClient, mediaStatus: GCKMediaStatus): boolean;
}
declare var GCKRemoteMediaClientAdInfoParserDelegate: {

	prototype: GCKRemoteMediaClientAdInfoParserDelegate;
};

interface GCKRemoteMediaClientListener extends NSObjectProtocol {

	remoteMediaClientDidInsertQueueItemsWithIDsBeforeItemWithID?(client: GCKRemoteMediaClient, queueItemIDs: NSArray<number>, beforeItemID: number): void;

	remoteMediaClientDidReceiveQueueItemIDs?(client: GCKRemoteMediaClient, queueItemIDs: NSArray<number>): void;

	remoteMediaClientDidReceiveQueueItems?(client: GCKRemoteMediaClient, queueItems: NSArray<GCKMediaQueueItem>): void;

	remoteMediaClientDidRemoveQueueItemsWithIDs?(client: GCKRemoteMediaClient, queueItemIDs: NSArray<number>): void;

	remoteMediaClientDidStartMediaSessionWithID?(client: GCKRemoteMediaClient, sessionID: number): void;

	remoteMediaClientDidUpdateMediaMetadata?(client: GCKRemoteMediaClient, mediaMetadata: GCKMediaMetadata): void;

	remoteMediaClientDidUpdateMediaStatus?(client: GCKRemoteMediaClient, mediaStatus: GCKMediaStatus): void;

	remoteMediaClientDidUpdatePreloadStatus?(client: GCKRemoteMediaClient): void;

	remoteMediaClientDidUpdateQueue?(client: GCKRemoteMediaClient): void;

	remoteMediaClientDidUpdateQueueItemsWithIDs?(client: GCKRemoteMediaClient, queueItemIDs: NSArray<number>): void;
}
declare var GCKRemoteMediaClientListener: {

	prototype: GCKRemoteMediaClientListener;
};

declare class GCKRequest extends NSObject {

	static alloc(): GCKRequest; // inherited from NSObject

	static applicationRequest(): GCKRequest;

	static new(): GCKRequest; // inherited from NSObject

	delegate: GCKRequestDelegate;

	readonly error: GCKError;

	readonly external: boolean;

	readonly inProgress: boolean;

	readonly requestID: number;

	abortWi