diff --git a/example/ReactNativeYouTubeExample.typescript.tsx b/example/ReactNativeYouTubeExample.typescript.tsx
new file mode 100644
index 00000000..74c65e2d
--- /dev/null
+++ b/example/ReactNativeYouTubeExample.typescript.tsx
@@ -0,0 +1,404 @@
+/*
+ * Typescript example.
+ *
+ * Before use:
+ * 1) Rename this file to ReactNativeYoutubeExample.tsx (remove the ".typescript" part)
+ * 2) Delete (or move) the .js counterpart
+ */
+
+import React from 'react';
+
+import {
+  StyleSheet,
+  View,
+  Text,
+  ScrollView,
+  PixelRatio,
+  Platform,
+  Button,
+  Dimensions,
+} from 'react-native';
+
+import YouTube, {
+  YouTubeStandaloneIOS,
+  YouTubeStandaloneAndroid,
+  YouTubeState,
+  OnErrorArg,
+  OnChangeStateArg,
+} from 'react-native-youtube';
+
+interface State {
+  isReady: boolean
+  status?: YouTubeState
+  quality?: string
+  error?: string
+  isPlaying: boolean
+  isLooping: boolean
+  duration: number
+  currentTime: number
+  isFullscreen: boolean
+  playerWidth: number
+  videosIndex?: number
+};
+
+export default class ReactNativeYouTubeExample extends React.Component<{}, State> {
+  state: State = {
+    isReady: false,
+    isPlaying: true,
+    isLooping: true,
+    duration: 0,
+    currentTime: 0,
+    isFullscreen: false,
+    playerWidth: Dimensions.get('window').width,
+  };
+
+  _youTubeRef = React.createRef<YouTube>();
+
+  render() {
+    return (
+      <ScrollView style={styles.container}>
+        <Text style={styles.welcome}>{'<YouTube /> TYPESCRIPT component for React Native.'}</Text>
+
+        <YouTube
+          ref={this._youTubeRef}
+          // You must have an API Key for the player to load in Android
+          apiKey="YOUR_API_KEY"
+          // Un-comment one of videoId / videoIds / playlist.
+          // You can also edit these props while Hot-Loading in development mode to see how
+          // it affects the loaded native module
+          videoId="xuCn8ux2gbs"
+          // videoIds={['uMK0prafzw0', 'qzYgSecGQww', 'XXlZfc1TrD0', 'czcjU1w-c6k']}
+          // playlistId="PLF797E961509B4EB5"
+          play={this.state.isPlaying}
+          loop={this.state.isLooping}
+          fullscreen={this.state.isFullscreen}
+          controls={1}
+          style={[
+            { height: PixelRatio.roundToNearestPixel(this.state.playerWidth / (16 / 9)) },
+            styles.player,
+          ]}
+          onError={({ error }) => {
+            console.log('error', error)
+            this.setState({ error })
+          }}
+          onReady={() => {
+            this.setState({ isReady: true });
+          }}
+          onChangeState={(arg: OnChangeStateArg) => {
+            console.log('state', arg)
+            const { state } = arg
+            // when state == seeking: arg.currentTime exists
+            if (state !== "stopped" && this.state.error) {
+              // reset errors
+              console.log('unsetting error')
+              this.setState({ error: undefined })
+            }
+            this.setState({ status: state })
+          }}
+          onChangeQuality={({ quality }) => {
+            console.log('quality', quality);
+            this.setState({ quality });
+          }}
+          onChangeFullscreen={({ isFullscreen }) => {
+            console.log('isFull', isFullscreen);
+            this.setState({ isFullscreen });
+          }}
+          onProgress={(e: any) => {
+            console.log('prog', e)
+            this.setState({ currentTime: e.currentTime });
+          }}
+        />
+
+        {/* Playing / Looping */}
+        <View style={styles.buttonGroup}>
+          <Button
+            title={this.state.status == 'playing' ? 'Pause' : 'Play'}
+            color={this.state.status == 'playing' ? 'red' : undefined}
+            onPress={() => {
+              this.setState((e: any) => ({ isPlaying: !this.state.isPlaying }));
+            }}
+          />
+          <Text> </Text>
+          <Button
+            title={this.state.isLooping ? 'Looping' : 'Not Looping'}
+            color={this.state.isLooping ? 'green' : undefined}
+            onPress={() => {
+              this.setState((e: any) => ({ isLooping: !this.state.isLooping }));
+            }}
+          />
+        </View>
+
+        {/* Previous / Next video */}
+        <View style={styles.buttonGroup}>
+          <Button
+            title="Previous Video"
+            onPress={() => {
+              this._youTubeRef.current?.previousVideo();
+            }}
+          />
+          <Text> </Text>
+          <Button
+            title="Next Video"
+            onPress={() => {
+              this._youTubeRef.current?.nextVideo();
+            }}
+          />
+        </View>
+
+        {/* Go To Specific time in played video with seekTo() */}
+        <View style={styles.buttonGroup}>
+          <Button
+            title="15 Seconds"
+            onPress={() => {
+              this._youTubeRef.current?.seekTo(15);
+            }}
+          />
+          <Text> </Text>
+          <Button
+            title="2 Minutes"
+            onPress={() => {
+              this._youTubeRef.current?.seekTo(2 * 60);
+            }}
+          />
+          <Text> </Text>
+          <Button
+            title="15 Minutes"
+            onPress={() => {
+              this._youTubeRef.current?.seekTo(15 * 60);
+            }}
+          />
+        </View>
+
+        {/* Play specific video in a videoIds array by index */}
+        {this._youTubeRef.current?.props.videoIds &&
+          Array.isArray(this._youTubeRef.current?.props.videoIds) && (
+            <View style={styles.buttonGroup}>
+              {this._youTubeRef.current?.props.videoIds.map((videoId: string, i: number) => (
+                <React.Fragment key={i}>
+                  <Button
+                    title={`Video ${i}`}
+                    onPress={() => {
+                      this._youTubeRef.current?.playVideoAt(i);
+                    }}
+                  />
+                  <Text> </Text>
+                </React.Fragment>
+              ))}
+            </View>
+          )}
+
+        {/* Get current played video's position index when playing videoIds (and playlist in iOS) */}
+        <View style={styles.buttonGroup}>
+          <Button
+            title={'Get Videos Index: ' + this.state.videosIndex}
+            onPress={() => {
+              this._youTubeRef.current
+                ?.getVideosIndex()
+                .then(index => {
+                  this.setState({ videosIndex: index });
+                })
+                .catch((error: any) => {
+                  this.setState({ error });
+                });
+            }}
+          />
+        </View>
+
+        {/* Fullscreen */}
+        {!this.state.isFullscreen && (
+          <View style={styles.buttonGroup}>
+            <Button
+              title="Set Fullscreen"
+              onPress={() => {
+                this.setState({ isFullscreen: true });
+              }}
+            />
+          </View>
+        )}
+
+        {/* Get Duration (iOS) */}
+        {Platform.OS === 'ios' && (
+          <View style={styles.buttonGroup}>
+            <Button
+              title="Get Duration (iOS)"
+              onPress={() => {
+                this._youTubeRef.current?.getDuration()
+                  .then((duration: number) => {
+                    this.setState({ duration });
+                  })
+                  .catch((error: any) => {
+                    this.setState({ error });
+                  });
+              }}
+            />
+          </View>
+        )}
+
+        {/* Get Progress & Duration (Android) */}
+        {Platform.OS === 'android' && (
+          <View style={styles.buttonGroup}>
+            <Button
+              title="Get Progress & Duration (Android)"
+              onPress={() => {
+                this._youTubeRef.current?.getCurrentTime()
+                  .then((currentTime: any) => {
+                    this.setState({ currentTime });
+                  })
+                  .catch((errorMessage: any) => {
+                    this.setState({ error: errorMessage });
+                  });
+
+                this._youTubeRef.current?.getDuration()
+                  .then((duration: number) => {
+                    this.setState({ duration });
+                  })
+                  .catch((errorMessage: any) => {
+                    this.setState({ error: errorMessage });
+                  });
+              }}
+            />
+          </View>
+        )}
+
+        {/* Standalone Player (iOS) */}
+        {Platform.OS === 'ios' && YouTubeStandaloneIOS && (
+          <View style={styles.buttonGroup}>
+            <Button
+              title="Launch Standalone Player"
+              onPress={() => {
+                YouTubeStandaloneIOS.playVideo('KVZ-P-ZI6W4')
+                  .then((message: any) => {
+                    console.log(message);
+                  })
+                  .catch((errorMessage: any) => {
+                    this.setState({ error: errorMessage });
+                  });
+              }}
+            />
+          </View>
+        )}
+
+        {/* Standalone Player (Android) */}
+        {Platform.OS === 'android' && YouTubeStandaloneAndroid && (
+          <View style={styles.buttonGroup}>
+            <Button
+              title="Standalone: One Video"
+              onPress={() => {
+                YouTubeStandaloneAndroid.playVideo({
+                  apiKey: 'YOUR_API_KEY',
+                  videoId: 'KVZ-P-ZI6W4',
+                  autoplay: true,
+                  lightboxMode: false,
+                  startTime: 124.5,
+                })
+                  .then(() => {
+                    console.log('Android Standalone Player Finished');
+                  })
+                  .catch((errorMessage: any) => {
+                    this.setState({ error: errorMessage });
+                  });
+              }}
+            />
+            <Text> </Text>
+            <Button
+              title="Videos"
+              onPress={() => {
+                YouTubeStandaloneAndroid.playVideos({
+                  apiKey: 'YOUR_API_KEY',
+                  videoIds: ['HcXNPI-IPPM', 'XXlZfc1TrD0', 'czcjU1w-c6k', 'uMK0prafzw0'],
+                  autoplay: false,
+                  lightboxMode: true,
+                  startIndex: 1,
+                  startTime: 99.5,
+                })
+                  .then(() => {
+                    console.log('Android Standalone Player Finished');
+                  })
+                  .catch((errorMessage: any) => {
+                    this.setState({ error: errorMessage });
+                  });
+              }}
+            />
+            <Text> </Text>
+            <Button
+              title="Playlist"
+              onPress={() => {
+                YouTubeStandaloneAndroid.playPlaylist({
+                  apiKey: 'YOUR_API_KEY',
+                  playlistId: 'PLF797E961509B4EB5',
+                  autoplay: false,
+                  lightboxMode: false,
+                  startIndex: 2,
+                  startTime: 100.5,
+                })
+                  .then(() => {
+                    console.log('Android Standalone Player Finished');
+                  })
+                  .catch((errorMessage: any) => {
+                    this.setState({ error: errorMessage });
+                  });
+              }}
+            />
+          </View>
+        )}
+
+        {/* Reload iFrame for updated props (Only needed for iOS) */}
+        {Platform.OS === 'ios' && (
+          <View style={styles.buttonGroup}>
+            <Button
+              title="Reload iFrame (iOS)"
+              onPress={() => {
+                this._youTubeRef.current?.reloadIframe();
+              }}
+            />
+          </View>
+        )}
+
+        <Text style={styles.instructions}>
+          {this.state.isReady ? 'Player is ready' : 'Player setting up...'}
+        </Text>
+        <Text style={styles.instructions}>Status: {this.state.status}</Text>
+        <Text style={styles.instructions}>Quality: {this.state.quality}</Text>
+
+        {/* Show Progress */}
+        <Text style={styles.instructions}>
+          Progress: {Math.trunc(this.state.currentTime)}s ({Math.trunc(this.state.duration / 60)}:
+          {Math.trunc(this.state.duration % 60)}s)
+          {Platform.OS !== 'ios' && <Text> (Click Update Progress & Duration)</Text>}
+        </Text>
+
+        <Text style={styles.instructions}>
+          {this.state.error ? 'Error: ' + this.state.error : ''}
+        </Text>
+      </ScrollView>
+    );
+  }
+}
+
+const styles = StyleSheet.create({
+  container: {
+    backgroundColor: 'white',
+  },
+  welcome: {
+    fontSize: 20,
+    textAlign: 'center',
+    margin: 10,
+  },
+  button: {
+    margin: 1,
+  },
+  buttonGroup: {
+    flexDirection: 'row',
+    alignSelf: 'center',
+    paddingBottom: 5,
+  },
+  instructions: {
+    textAlign: 'center',
+    color: '#333333',
+    marginBottom: 5,
+  },
+  player: {
+    alignSelf: 'stretch',
+    marginVertical: 10,
+  },
+});
diff --git a/example/package.json b/example/package.json
index 15f324e2..21c8f591 100644
--- a/example/package.json
+++ b/example/package.json
@@ -7,7 +7,7 @@
     "ios": "react-native run-ios",
     "start": "react-native start",
     "preinstall": "npm pack ..",
-    "install-root": "npm run pack-root && npm install react-native-youtube-2.0.0.tgz",
+    "install-root": "npm run pack-root && npm install react-native-youtube-2.0.1.tgz",
     "reinstall-native-ios": "npm run install-root && npm run postinstall",
     "postinstall": "cd ios && pod install && cd ..",
     "clean": "rimraf ios/build ios/Pods android/.gradle android/app/build package-lock.json yarn-lock.json node_modules",
@@ -19,13 +19,15 @@
     "prettier": "^2.0.4",
     "react": "16.9.0",
     "react-native": "0.61.5",
-    "react-native-youtube": "file:react-native-youtube-2.0.0.tgz",
+    "react-native-youtube": "file:react-native-youtube-2.0.1.tgz",
     "rimraf": "^3.0.0"
   },
   "devDependencies": {
     "@babel/core": "^7.6.2",
     "@babel/runtime": "^7.6.2",
     "@react-native-community/eslint-config": "^0.0.5",
+    "@types/react": "^16.9.0",
+    "@types/react-native": "^0.61.5",
     "babel-jest": "^24.9.0",
     "eslint": "^6.5.1",
     "jest": "^24.9.0",
diff --git a/example/tsconfig.json b/example/tsconfig.json
new file mode 100644
index 00000000..3c78a191
--- /dev/null
+++ b/example/tsconfig.json
@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "allowSyntheticDefaultImports": true,
+    "jsx": "react-native",
+    "lib": ["dom", "esnext"],
+    "moduleResolution": "node",
+    "noEmit": true,
+    "skipLibCheck": true,
+    "resolveJsonModule": true,
+    "strict": true
+  }
+}
diff --git a/main.d.ts b/main.d.ts
index d771db74..6f4969fd 100644
--- a/main.d.ts
+++ b/main.d.ts
@@ -1,25 +1,44 @@
 import * as React from 'react';
 import { StyleProp, ViewStyle } from 'react-native';
 
+export type OnErrorArg = { error: string }
+
+export type OnChangeQualityArg = { quality: string } // TODO doublecheck, havent seen this
+
+export type OnChangeFullscreenArg = { isFullscreen: boolean }
+
+export type OnProgressArg = { currentTime: number }
+
+export type OnChangeStateArg =
+  { state: 'started' } |
+  { state: 'playing' } |
+  { state: 'buffering' } |
+  { state: 'paused' } |
+  { state: 'stopped' } |
+  { state: 'seeking', currentTime: number }
+
+export type YouTubeState = 'started' | 'playing' | 'buffering' | 'paused' | 'stopped' | 'seeking'
+
 export interface YouTubeProps {
+  apiKey: string;
   videoId?: string;
   videoIds?: string[];
   playlistId?: string;
   play?: boolean;
   loop?: boolean;
   fullscreen?: boolean;
-  controls?: 1 | 2 | 3;
+  controls?: 0 | 1 | 2;
   showinfo?: boolean;
   modestbranding?: boolean;
   showFullscreenButton?: boolean;
   rel?: boolean;
   origin?: string;
-  onError?: (event: any) => void;
-  onReady?: (event: any) => void;
-  onChangeState?: () => void;
-  onChangeQuality?: () => void;
-  onChangeFullscreen?: (event: any) => void;
-  onProgress?: (event: any) => void;
+  onError?: (arg: OnErrorArg) => void;
+  onReady?: () => void;
+  onChangeState?: (arg: OnChangeStateArg) => void;
+  onChangeQuality?: (arg: OnChangeQualityArg) => void;
+  onChangeFullscreen?: (arg: OnChangeFullscreenArg) => void;
+  onProgress?: (arg: OnProgressArg) => void;
   style?: StyleProp<ViewStyle>;
 }
 
@@ -56,7 +75,7 @@ export declare const YouTubeStandaloneAndroid: {
   }): Promise<void>;
   playPlaylist(params: {
     apiKey: string;
-    playlistId: string[];
+    playlistId: string;
     autoplay?: boolean;
     lightboxMode?: boolean;
     startIndex?: number;
diff --git a/tests/type-test.tsx b/tests/type-test.tsx
index 19eadd58..b865edfc 100644
--- a/tests/type-test.tsx
+++ b/tests/type-test.tsx
@@ -1,3 +1,5 @@
+// Before use: npm install react @types/react
+
 import * as React from 'react';
 import YouTube, { YouTubeStandaloneAndroid, YouTubeStandaloneIOS } from '../main';
 
@@ -9,16 +11,17 @@ const YouTubeTest = () => {
   YouTubeStandaloneIOS.playVideo('foo');
   const videoRef = React.useRef<YouTube>(null)
   React.useEffect(()=>{
-    videoRef.current.getCurrentTime()
-    videoRef.current.nextVideo()
-    videoRef.current.previousVideo()
-    videoRef.current.reloadIframe()
-    videoRef.current.getDuration()
-    videoRef.current.playVideoAt(1)
-    videoRef.current.seekTo(1000)
+    videoRef.current?.getCurrentTime()
+    videoRef.current?.nextVideo()
+    videoRef.current?.previousVideo()
+    videoRef.current?.reloadIframe()
+    videoRef.current?.getDuration()
+    videoRef.current?.playVideoAt(1)
+    videoRef.current?.seekTo(1000)
   },[])
   return (
     <YouTube
+      apiKey={'YOUR_API_KEY_HERE'}
       ref={videoRef}
       videoId={'foo'}
       videoIds={['foo', 'bar']}
@@ -32,12 +35,12 @@ const YouTubeTest = () => {
       showFullscreenButton
       rel
       origin={'foo'}
-      onError={(event) => {}}
-      onReady={(event) => {}}
-      onChangeState={() => {}}
-      onChangeQuality={() => {}}
-      onChangeFullscreen={(event) => {}}
-      onProgress={() => {}}
+      onError={({error}) => {}}
+      onReady={() => {}}
+      onChangeState={({state}) => {}}
+      onChangeQuality={({quality}) => {}}
+      onChangeFullscreen={({isFullscreen}) => {}}
+      onProgress={({currentTime}) => {}}
       style={{ flex: 1 }}
     />
   );