@codelab/nativescript-cast/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: GCKVASTAdsRequest;

	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(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;
}

declare class GCKAdBreakClipInfoBuilder extends NSObject {

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

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

	adBreakClipID: string;

	clickThroughURL: NSURL;

	contentID: string;

	contentURL: NSURL;

	customData: any;

	duration: number;

	hlsSegmentFormat: GCKHLSSegmentFormat;

	mimeType: string;

	posterURL: NSURL;

	title: string;

	vastAdsRequest: GCKVASTAdsRequest;

	whenSkippable: number;

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

	constructor(o: { adBreakClipInfo: GCKAdBreakClipInfo; });

	build(): GCKAdBreakClipInfo;

	initWithAdBreakClipID(adBreakClipID: string): this;

	initWithAdBreakClipInfo(adBreakClipInfo: GCKAdBreakClipInfo): this;
}

declare class GCKAdBreakClipVastAdsRequest extends GCKVASTAdsRequest {

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

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

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(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;

	initWithPlaybackPosition(playbackPosition: number): this;
}

declare class GCKAdBreakInfoBuilder extends NSObject {

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

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

	adBreakClipIDs: NSArray<string>;

	adBreakID: string;

	embedded: boolean;

	playbackPosition: number;

	watched: boolean;

	constructor(o: { adBreakID: string; adBreakClipIds: NSArray<string> | string[]; });

	constructor(o: { adBreakInfo: GCKAdBreakInfo; });

	build(): GCKAdBreakInfo;

	initWithAdBreakIDAdBreakClipIds(adBreakID: string, adBreakClipIDs: NSArray<string> | string[]): this;

	initWithAdBreakInfo(adBreakInfo: GCKAdBreakInfo): 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;

	readonly whenSkippable: 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 iconURL: NSURL;

	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> | string[]; });

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

	encodeWithCoder(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;

	initWithDiscoveryCriteria(discoveryCriteria: GCKDiscoveryCriteria): this;

	initWithReceiverApplicationID(applicationID: string): this;

	initWithSupportedNamespaces(namespaces: NSArray<string> | 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(coder: NSCoder): void;

	initWithCGColor(color: any): this;

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

	initWithCSSString(CSSString: string): this;

	initWithCoder(coder: 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(coder: NSCoder): void;

	hasCapabilities(deviceCapabilities: GCKDeviceCapabilities): boolean;

	initWithCoder(coder: NSCoder): this;

	isSameDeviceAs(other: GCKDevice): boolean;

	removeAllAttributes(): void;

	removeAttributeForKey(key: string): void;

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

declare const enum GCKDeviceCapabilities {

	CapabilityVideoOut = 1,

	CapabilityVideoIn = 2,

	CapabilityAudioOut = 4,

	CapabilityAudioIn = 8,

	CapabilityMultizoneGroup = 32,

	CapabilityDynamicGroup = 64,

	CapabilityMasterOrFixedVolume = 2048,

	CapabilityAttenuationOrFixedVolume = 4096,

	CapabilityDynamicGroupingSupported = 65536
}

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(coder: NSCoder): void;

	initWithApplicationID(applicationID: string): this;

	initWithCoder(coder: 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 {

	didHaveDiscoveredDeviceWhenStartingDiscovery?(): void;

	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 GCKDynamicDevice extends NSObject implements NSCopying, NSSecureCoding {

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

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

	readonly capabilities: GCKDeviceCapabilities;

	readonly deviceID: string;

	readonly friendlyName: string;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

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

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

	encodeWithCoder(coder: NSCoder): void;

	hasCapabilities(deviceCapabilities: GCKDeviceCapabilities): boolean;

	initWithCoder(coder: NSCoder): this;
}

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,

	InvalidResponse = 27,

	FailedSessionUpdate = 28,

	SessionIsNotActive = 29,

	MediaLoadFailed = 30,

	InvalidMediaPlayerState = 31,

	NoMediaSession = 32,

	NotCastSession = 33,

	MediaError = 34,

	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,

	DeviceAuthenticationMessageParseFailure = 100,

	DeviceAuthenticationMessageChallengeReceivedFailure = 101,

	DeviceAuthenticationTimeoutFailure = 102
}

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(coder: NSCoder): void;

	initWithCoder(coder: 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

	androidReceiverCompatible: boolean;

	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; });

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

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

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

	encodeWithCoder(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;

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

	initWithRelaunchIfRunning(relaunchIfRunning: boolean): this;

	initWithRelaunchIfRunningAndroidReceiverCompatible(relaunchIfRunning: boolean, androidReceiverCompatible: boolean): this;

	initWithRelaunchIfRunningLanguageCodeAndroidReceiverCompatible(relaunchIfRunning: boolean, languageCode: string, androidReceiverCompatible: 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> | string[]): void;

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

	addFunctionNames(functionNames: NSArray<string> | string[]): void;

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

	addMessagePatterns(messagePatterns: NSArray<string> | string[]): void;

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

	reset(): void;

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

	setLoggingLevelForFunctions(minimumLevel: GCKLoggerLevel, functionNames: NSArray<string> | 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 VMAP: GCKVASTAdsRequest;

	readonly adBreakClips: NSArray<GCKAdBreakClipInfo>;

	readonly adBreaks: NSArray<GCKAdBreakInfo>;

	readonly contentID: string;

	readonly contentType: string;

	readonly contentURL: NSURL;

	readonly customData: any;

	readonly entity: string;

	readonly mediaTracks: NSArray<GCKMediaTrack>;

	readonly metadata: GCKMediaMetadata;

	readonly startAbsoluteTime: number;

	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> | GCKAdBreakInfo[]; adBreakClips: NSArray<GCKAdBreakClipInfo> | GCKAdBreakClipInfo[]; streamDuration: number; mediaTracks: NSArray<GCKMediaTrack> | GCKMediaTrack[]; textTrackStyle: GCKMediaTextTrackStyle; customData: any; });

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

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

	encodeWithCoder(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;

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

	initWithContentIDStreamTypeContentTypeMetadataStreamDurationMediaTracksTextTrackStyleCustomData(contentID: string, streamType: GCKMediaStreamType, contentType: string, metadata: GCKMediaMetadata, streamDuration: number, mediaTracks: NSArray<GCKMediaTrack> | 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

	VMAP: GCKVASTAdsRequest;

	adBreakClips: NSArray<GCKAdBreakClipInfo>;

	adBreaks: NSArray<GCKAdBreakInfo>;

	contentID: string;

	contentType: string;

	contentURL: NSURL;

	customData: any;

	entity: string;

	mediaTracks: NSArray<GCKMediaTrack>;

	metadata: GCKMediaMetadata;

	startAbsoluteTime: number;

	streamDuration: number;

	streamType: GCKMediaStreamType;

	textTrackStyle: GCKMediaTextTrackStyle;

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

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

	constructor(o: { contentURL: NSURL; });

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

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

	build(): GCKMediaInformation;

	initWithContentID(contentID: string): this;

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

	initWithContentURL(contentURL: NSURL): this;

	initWithEntity(entity: string): this;

	initWithMediaInformation(mediaInfo: GCKMediaInformation): this;
}

declare class GCKMediaLiveSeekableRange extends NSObject implements NSCopying, NSSecureCoding {

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

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

	readonly endTime: number;

	readonly isLiveDone: boolean;

	readonly isMovingWindow: boolean;

	readonly startTime: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

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

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

	encodeWithCoder(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): 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(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;
}

declare class GCKMediaLoadRequestData extends NSObject implements NSCopying, NSSecureCoding {

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

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

	readonly activeTrackIDs: NSArray<number>;

	readonly autoplay: number;

	readonly credentials: string;

	readonly credentialsType: string;

	readonly customData: any;

	readonly mediaInformation: GCKMediaInformation;

	readonly playbackRate: number;

	readonly queueData: GCKMediaQueueData;

	readonly startTime: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

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

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

	encodeWithCoder(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;
}

declare class GCKMediaLoadRequestDataBuilder extends NSObject {

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

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

	activeTrackIDs: NSArray<number>;

	autoplay: number;

	credentials: string;

	credentialsType: string;

	customData: any;

	mediaInformation: GCKMediaInformation;

	playbackRate: number;

	queueData: GCKMediaQueueData;

	startTime: number;

	constructor(o: { mediaLoadRequestData: GCKMediaLoadRequestData; });

	build(): GCKMediaLoadRequestData;

	initWithMediaLoadRequestData(requestData: GCKMediaLoadRequestData): 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(coder: NSCoder): void;

	images(): NSArray<any>;

	initWithCoder(coder: 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,

	AudioBookChapter = 5,

	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 GCKMediaQueue extends NSObject {

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

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

	readonly cacheSize: number;

	readonly cachedItemCount: number;

	readonly itemCount: number;

	constructor(o: { remoteMediaClient: GCKRemoteMediaClient; });

	constructor(o: { remoteMediaClient: GCKRemoteMediaClient; cacheSize: number; });

	constructor(o: { remoteMediaClient: GCKRemoteMediaClient; cacheSize: number; maxFetchCount: number; });

	addDelegate(delegate: GCKMediaQueueDelegate): void;

	clear(): void;

	indexOfItemWithID(itemID: number): number;

	initWithRemoteMediaClient(remoteMediaClient: GCKRemoteMediaClient): this;

	initWithRemoteMediaClientCacheSize(remoteMediaClient: GCKRemoteMediaClient, cacheSize: number): this;

	initWithRemoteMediaClientCacheSizeMaxFetchCount(remoteMediaClient: GCKRemoteMediaClient, cacheSize: number, maxFetchCount: number): this;

	itemAtIndex(index: number): GCKMediaQueueItem;

	itemAtIndexFetchIfNeeded(index: number, fetch: boolean): GCKMediaQueueItem;

	itemIDAtIndex(index: number): number;

	reload(): void;

	removeDelegate(delegate: GCKMediaQueueDelegate): void;
}

declare class GCKMediaQueueContainerMetadata extends NSObject implements NSCopying, NSSecureCoding {

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

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

	readonly authors: NSArray<string>;

	readonly containerDuration: number;

	readonly containerImages: NSArray<GCKImage>;

	readonly containerType: GCKMediaQueueContainerType;

	readonly narrators: NSArray<string>;

	readonly publisher: string;

	readonly releaseDate: string;

	readonly sections: NSArray<GCKMediaMetadata>;

	readonly title: string;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

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

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

	encodeWithCoder(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;
}

declare class GCKMediaQueueContainerMetadataBuilder extends NSObject {

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

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

	authors: NSArray<string>;

	containerDuration: number;

	containerImages: NSArray<GCKImage>;

	containerType: GCKMediaQueueContainerType;

	narrators: NSArray<string>;

	publisher: string;

	releaseDate: string;

	sections: NSArray<GCKMediaMetadata>;

	title: string;

	constructor(o: { containerMetadata: GCKMediaQueueContainerMetadata; });

	constructor(o: { containerType: GCKMediaQueueContainerType; });

	build(): GCKMediaQueueContainerMetadata;

	initWithContainerMetadata(containerMetadata: GCKMediaQueueContainerMetadata): this;

	initWithContainerType(containerType: GCKMediaQueueContainerType): this;
}

declare const enum GCKMediaQueueContainerType {

	Generic = 0,

	AudioBook = 1
}

declare class GCKMediaQueueData extends NSObject implements NSCopying, NSSecureCoding {

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

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

	readonly containerMetadata: GCKMediaQueueContainerMetadata;

	readonly entity: string;

	readonly items: NSArray<GCKMediaQueueItem>;

	readonly name: string;

	readonly queueID: string;

	readonly queueType: GCKMediaQueueType;

	readonly repeatMode: GCKMediaRepeatMode;

	readonly startIndex: number;

	readonly startTime: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

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

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

	encodeWithCoder(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;
}

declare class GCKMediaQueueDataBuilder extends NSObject {

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

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

	containerMetadata: GCKMediaQueueContainerMetadata;

	entity: string;

	items: NSArray<GCKMediaQueueItem>;

	name: string;

	queueID: string;

	queueType: GCKMediaQueueType;

	repeatMode: GCKMediaRepeatMode;

	startIndex: number;

	startTime: number;

	constructor(o: { queueData: GCKMediaQueueData; });

	constructor(o: { queueType: GCKMediaQueueType; });

	build(): GCKMediaQueueData;

	initWithQueueData(queueData: GCKMediaQueueData): this;

	initWithQueueType(queueType: GCKMediaQueueType): this;
}

interface GCKMediaQueueDelegate extends NSObjectProtocol {

	mediaQueueDidChange?(queue: GCKMediaQueue): void;

	mediaQueueDidInsertItemsInRange?(queue: GCKMediaQueue, range: NSRange): void;

	mediaQueueDidReloadItems?(queue: GCKMediaQueue): void;

	mediaQueueDidRemoveItemsAtIndexes?(queue: GCKMediaQueue, indexes: NSArray<number> | number[]): void;

	mediaQueueDidUpdateItemsAtIndexes?(queue: GCKMediaQueue, indexes: NSArray<number> | number[]): void;

	mediaQueueWillChange?(queue: GCKMediaQueue): void;
}
declare var GCKMediaQueueDelegate: {

	prototype: GCKMediaQueueDelegate;
};

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> | number[]; customData: any; });

	constructor(o: { mediaInformation: GCKMediaInformation; autoplay: boolean; startTime: number; preloadTime: number; activeTrackIDs: NSArray<number> | 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> | number[], customData: any): this;

	initWithMediaInformationAutoplayStartTimePreloadTimeActiveTrackIDsCustomData(mediaInformation: GCKMediaInformation, autoplay: boolean, startTime: number, preloadTime: number, activeTrackIDs: NSArray<number> | 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(coder: NSCoder): void;

	initWithCoder(coder: NSCoder): this;
}

declare const enum GCKMediaQueueType {

	Generic = 0,

	Album = 1,

	Playlist = 2,

	AudioBook = 3,

	RadioStation = 4,

	PodcastSeries = 5,

	TVSeries = 6,

	VideoPlayList = 7,

	LiveTV = 8,

	Movie = 9
}

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(coder: NSCoder): void;

	initWithCoder(coder: 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;

	seekToInfinite: boolean;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

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

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

	encodeWithCoder(coder: NSCoder): void;

	initWithCoder(coder: 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 liveSeekableRange: GCKMediaLiveSeekableRange;

	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 queueData: GCKMediaQueueData;

	readonly queueHasCurrentItem: boolean;

	readonly queueHasLoadingItem: boolean;

	readonly queueHasNextItem: boolean;

	readonly queueHasPreviousItem: boolean;

	readonly queueItemCount: number;

	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;

	queueIndexForItemID(itemID: number): number;

	queueItemAtIndex(index: number): GCKMediaQueueItem;

	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(coder: NSCoder): void;

	initWithCoder(coder: 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(coder: NSCoder): void;

	initWithCoder(coder: 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 GCKDynamicDevice implements NSCopying, NSSecureCoding {

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

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

	readonly muted: boolean;

	readonly volumeLevel: number;

	static readonly supportsSecureCoding: boolean; // inherited from NSSecureCoding

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